From 39bfd0f99d118efb8e7b97d7ae241ec04499fdd8 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 27 Aug 2026 04:47:10 +0000
Subject: [PATCH 1/2] refactor: emit through ktsu.CodeBlocker.Templates [minor]

The C# syntax template model moved to ktsu.CodeBlocker 1.3.0, so the local copy
under Templates/ goes away and the generators describe their output with the
package's model instead.

The migration is mostly mechanical - the collection properties are read-only
now, so object initializers use collection-initializer syntax, and a type's
declaration keyword comes from ClassTemplate.Kind rather than from free text in
Keywords. WithComments and WithInterfaces cover the few call sites that hold a
prebuilt sequence, which a read-only property cannot be assigned. TypeKind needs
a using alias because Microsoft.CodeAnalysis declares one too.

One substantive change: every BodyFactory used to write a leading space (" =>
Create(...)") because the old model spliced the body raw with no separator. The
package model supplies that separator itself, so the leading space became a
double space in the output and is removed at all 16 sites.

The committed output under Semantics.Quantities/Generated/ changes across 181
files, and all of it is the model doing its job:

  -internal static class ConversionConstants{
  +internal static class ConversionConstants
  +{

Types now open their brace on its own line and close with "}" instead of "};",
members are separated by a blank line, and doc comments sit at the member's
indent instead of at column zero - the previous output had every "/// <summary>"
flush against the left margin directly after the preceding member.

PropertyTemplateTests is deleted rather than ported: it covered the local
PropertyTemplate, and ktsu.CodeBlocker now carries far better coverage of the
same behaviour, including the accessor cases this model could not express.

WriteFileHeader and WriteSourceFile go back to protected - they were narrowed to
private protected only because SourceFileTemplate was local, and it is public in
the package.

Test suite: 1015 passed, 92 failed - the same 92 Windows-path tests that fail on
main under Linux. The -4 against the previous run is exactly the deleted
PropertyTemplateTests.

Closes #187

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015sagQjzFv3cnFNM3G271TJ
---
 CLAUDE.md                                     |   4 +-
 Directory.Packages.props                      |   2 +-
 .../ConversionConstants.g.cs                  |   6 +-
 .../PhysicalDimensions.g.cs                   | 226 ++++---
 .../MetricMagnitudes.g.cs                     |   6 +-
 .../PhysicalConstants.g.cs                    | 418 +++++++------
 .../StorageTypes.g.cs                         |   6 +-
 .../AbsorbedDose.g.cs                         |  14 +-
 .../Acceleration1D.g.cs                       |  23 +-
 .../AccelerationMagnitude.g.cs                |  38 +-
 .../AcousticImpedance.g.cs                    |  11 +-
 .../ActivationEnergy.g.cs                     |  26 +-
 .../Admittance.g.cs                           |  20 +-
 .../Airspeed.g.cs                             |  32 +-
 .../Altitude.g.cs                             |  53 +-
 .../AmountOfSubstance.g.cs                    |  53 +-
 .../Angle.g.cs                                |  41 +-
 .../AngularAcceleration1D.g.cs                |  20 +-
 .../AngularAccelerationMagnitude.g.cs         |  35 +-
 .../AngularJerk1D.g.cs                        |  14 +-
 .../AngularJerkMagnitude.g.cs                 |  17 +-
 .../AngularMomentum1D.g.cs                    |  14 +-
 .../AngularMomentumMagnitude.g.cs             |  29 +-
 .../AngularSpeed.g.cs                         |  38 +-
 .../AngularVelocity1D.g.cs                    |  23 +-
 .../ApertureAngle.g.cs                        |  32 +-
 .../Area.g.cs                                 |  80 ++-
 .../AtmosphericPressure.g.cs                  |  35 +-
 .../AtomicMass.g.cs                           |  41 +-
 .../Bandwidth.g.cs                            |  26 +-
 .../Bearing.g.cs                              |  26 +-
 .../BulkModulus.g.cs                          |  35 +-
 .../Capacitance.g.cs                          |  26 +-
 .../Capacity.g.cs                             |  50 +-
 .../CatalyticActivity.g.cs                    |  20 +-
 .../Charge.g.cs                               |  17 +-
 .../ChargeMagnitude.g.cs                      |  38 +-
 .../ClockSpeed.g.cs                           |  26 +-
 .../Concentration.g.cs                        |  38 +-
 .../Conductance.g.cs                          |  17 +-
 .../CrossSectionalArea.g.cs                   |  41 +-
 .../Current1D.g.cs                            |  26 +-
 .../CurrentMagnitude.g.cs                     |  53 +-
 .../DecayTime.g.cs                            |  44 +-
 .../Density.g.cs                              |  29 +-
 .../Depth.g.cs                                |  53 +-
 .../Diameter.g.cs                             |  59 +-
 .../Displacement1D.g.cs                       |  47 +-
 .../Distance.g.cs                             |  53 +-
 .../Drag.g.cs                                 |  29 +-
 .../Duration.g.cs                             | 311 ++++++----
 .../DynamicViscosity.g.cs                     |  23 +-
 .../EMF.g.cs                                  |  23 +-
 .../ElectricConductivity.g.cs                 |  11 +-
 .../ElectricField1D.g.cs                      |  14 +-
 .../ElectricFieldMagnitude.g.cs               |  23 +-
 .../ElectricFlux.g.cs                         |  23 +-
 .../ElectricPowerDensity.g.cs                 |  17 +-
 .../Energy.g.cs                               | 107 ++--
 .../EnergyFluxDensity.g.cs                    |  20 +-
 .../Entropy.g.cs                              |  29 +-
 .../EnzymeActivity.g.cs                       |  23 +-
 .../EquivalentDose.g.cs                       |  14 +-
 .../Exposure.g.cs                             |  14 +-
 .../FieldOfView.g.cs                          |  32 +-
 .../FlowSpeed.g.cs                            |  32 +-
 .../Force1D.g.cs                              |  23 +-
 .../ForceMagnitude.g.cs                       |  68 ++-
 .../Frequency.g.cs                            |  29 +-
 .../Friction.g.cs                             |  29 +-
 .../Gain.g.cs                                 |  47 +-
 .../GaugePressure.g.cs                        |  35 +-
 .../GravitationalAcceleration.g.cs            |  23 +-
 .../GroundSpeed.g.cs                          |  32 +-
 .../GroupVelocity.g.cs                        |  32 +-
 .../HalfLife.g.cs                             |  44 +-
 .../Heading.g.cs                              |  26 +-
 .../Heat.g.cs                                 |  44 +-
 .../HeatCapacity.g.cs                         |  20 +-
 .../HeatFlowRate.g.cs                         |  29 +-
 .../HeatFlux.g.cs                             |  20 +-
 .../HeatTransferCoefficient.g.cs              |  11 +-
 .../Height.g.cs                               |  53 +-
 .../Illuminance.g.cs                          |  20 +-
 .../Impedance.g.cs                            |  26 +-
 .../Inductance.g.cs                           |  17 +-
 .../Irradiance.g.cs                           |  17 +-
 .../Jerk1D.g.cs                               |  20 +-
 .../JerkMagnitude.g.cs                        |  29 +-
 .../KinematicViscosity.g.cs                   |  20 +-
 .../KineticEnergy.g.cs                        |  44 +-
 .../Latency.g.cs                              |  44 +-
 .../Length.g.cs                               |  98 ++-
 .../Lift.g.cs                                 |  29 +-
 .../Loudness.g.cs                             |  11 +-
 .../Luminance.g.cs                            |  23 +-
 .../LuminousFlux.g.cs                         |  23 +-
 .../LuminousIntensity.g.cs                    |  26 +-
 .../MachNumber.g.cs                           |  47 +-
 .../MagneticFlux.g.cs                         |  41 +-
 .../MagneticFluxDensityMagnitude.g.cs         |  20 +-
 .../Mass.g.cs                                 |  86 ++-
 .../MassFlowRate.g.cs                         |  17 +-
 .../MolarEnergy.g.cs                          |  23 +-
 .../MolarEnthalpy.g.cs                        |  26 +-
 .../MolarMass.g.cs                            |  23 +-
 .../MomentOfInertia.g.cs                      |  23 +-
 .../Momentum1D.g.cs                           |  14 +-
 .../MomentumMagnitude.g.cs                    |  35 +-
 .../NoiseReductionCoefficient.g.cs            |  47 +-
 .../NormalForce.g.cs                          |  29 +-
 .../NuclearCrossSection.g.cs                  |  14 +-
 .../Offset.g.cs                               |  47 +-
 .../OpticalPower.g.cs                         |  11 +-
 .../Perimeter.g.cs                            |  53 +-
 .../Period.g.cs                               |  44 +-
 .../Permittivity.g.cs                         |  11 +-
 .../Phase.g.cs                                |  26 +-
 .../PhaseVelocity.g.cs                        |  32 +-
 .../Pitch.g.cs                                |  26 +-
 .../PotentialEnergy.g.cs                      |  44 +-
 .../Power.g.cs                                |  74 ++-
 .../Pressure.g.cs                             |  44 +-
 .../RadioactiveActivity.g.cs                  |  14 +-
 .../Radius.g.cs                               |  53 +-
 .../RateConstant.g.cs                         |  11 +-
 .../Ratio.g.cs                                |  74 ++-
 .../ReactionRate.g.cs                         |  17 +-
 .../ReflectionCoefficient.g.cs                |  41 +-
 .../RefractiveIndex.g.cs                      |  47 +-
 .../Resistance.g.cs                           |  29 +-
 .../ReverberationTime.g.cs                    |  44 +-
 .../ReynoldsNumber.g.cs                       |  47 +-
 .../Rotation.g.cs                             |  26 +-
 .../SamplingRate.g.cs                         |  26 +-
 .../Sensitivity.g.cs                          |  17 +-
 .../Sharpness.g.cs                            |  11 +-
 .../ShearModulus.g.cs                         |  35 +-
 .../SignedAngle.g.cs                          |  26 +-
 .../SignedRatio.g.cs                          |  47 +-
 .../Snap1D.g.cs                               |  14 +-
 .../SnapMagnitude.g.cs                        |  17 +-
 .../SoundAbsorption.g.cs                      |  47 +-
 .../SoundIntensity.g.cs                       |  20 +-
 .../SoundPower.g.cs                           |  29 +-
 .../SoundPressure.g.cs                        |  35 +-
 .../SoundSpeed.g.cs                           |  32 +-
 .../SoundTransmissionClass.g.cs               |  47 +-
 .../SpecificEntropy.g.cs                      |  20 +-
 .../SpecificGravity.g.cs                      |  47 +-
 .../SpecificHeat.g.cs                         |  17 +-
 .../Speed.g.cs                                |  65 +-
 .../Stress.g.cs                               |  35 +-
 .../SurfaceArea.g.cs                          |  41 +-
 .../SurfaceTension.g.cs                       |  20 +-
 .../Temperature.g.cs                          |  32 +-
 .../TemperatureDelta.g.cs                     |  17 +-
 .../TemperatureDrop.g.cs                      |  23 +-
 .../TemperatureRise.g.cs                      |  23 +-
 .../Tension.g.cs                              |  29 +-
 .../ThermalConductivity.g.cs                  |  11 +-
 .../ThermalDiffusivity.g.cs                   |  23 +-
 .../ThermalEnergy.g.cs                        |  44 +-
 .../ThermalExpansionCoefficient.g.cs          |  17 +-
 .../ThermalResistance.g.cs                    |  11 +-
 .../Thickness.g.cs                            |  53 +-
 .../Thrust.g.cs                               |  29 +-
 .../TimeConstant.g.cs                         |  44 +-
 .../Torque1D.g.cs                             |  17 +-
 .../TorqueMagnitude.g.cs                      |  38 +-
 .../Velocity1D.g.cs                           |  32 +-
 .../Voltage.g.cs                              |  23 +-
 .../VoltageDrop.g.cs                          |  23 +-
 .../VoltageMagnitude.g.cs                     |  74 ++-
 .../Volume.g.cs                               |  89 ++-
 .../VolumetricFlowRate.g.cs                   |  20 +-
 .../Wavelength.g.cs                           |  53 +-
 .../Weight.g.cs                               |  29 +-
 .../Width.g.cs                                |  53 +-
 .../WindSpeed.g.cs                            |  32 +-
 .../Work.g.cs                                 |  44 +-
 .../YoungsModulus.g.cs                        |  35 +-
 .../Units.g.cs                                | 573 ++++++------------
 .../CodeGen/GeneratorBase.cs                  |  11 +-
 .../Generators/ConversionsGenerator.cs        |  21 +-
 .../Generators/DimensionsGenerator.cs         |  57 +-
 .../Generators/LogarithmicScalesGenerator.cs  |   4 +-
 .../Generators/MagnitudesGenerator.cs         |  14 +-
 .../Generators/PhysicalConstantsGenerator.cs  |  49 +-
 .../Generators/PrecisionGenerator.cs          |  26 +-
 .../Generators/QuantitiesGenerator.cs         | 187 +++---
 .../Generators/UnitsGenerator.cs              |  62 +-
 .../SemanticsGenerator.cs                     |  10 +-
 .../TemplateExtensions.cs                     |  52 ++
 .../Templates/ClassTemplate.cs                | 152 -----
 .../Templates/ConstructorTemplate.cs          |  82 ---
 .../Templates/FieldTemplate.cs                |  27 -
 .../Templates/MemberTemplate.cs               |  26 -
 .../Templates/MethodTemplate.cs               |  66 --
 .../Templates/ParameterTemplate.cs            |  27 -
 .../Templates/PropertyTemplate.cs             |  89 ---
 .../Templates/SourceFileTemplate.cs           |  63 --
 .../Templates/TemplateBase.cs                 |  62 --
 .../Quantities/PropertyTemplateTests.cs       |  82 ---
 docs/physics-generator.md                     |   2 +
 205 files changed, 4818 insertions(+), 3590 deletions(-)
 create mode 100644 Semantics.SourceGenerators/TemplateExtensions.cs
 delete mode 100644 Semantics.SourceGenerators/Templates/ClassTemplate.cs
 delete mode 100644 Semantics.SourceGenerators/Templates/ConstructorTemplate.cs
 delete mode 100644 Semantics.SourceGenerators/Templates/FieldTemplate.cs
 delete mode 100644 Semantics.SourceGenerators/Templates/MemberTemplate.cs
 delete mode 100644 Semantics.SourceGenerators/Templates/MethodTemplate.cs
 delete mode 100644 Semantics.SourceGenerators/Templates/ParameterTemplate.cs
 delete mode 100644 Semantics.SourceGenerators/Templates/PropertyTemplate.cs
 delete mode 100644 Semantics.SourceGenerators/Templates/SourceFileTemplate.cs
 delete mode 100644 Semantics.SourceGenerators/Templates/TemplateBase.cs
 delete mode 100644 Semantics.Test/Quantities/PropertyTemplateTests.cs

diff --git a/CLAUDE.md b/CLAUDE.md
index 25fb6734..2dae46c7 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -41,7 +41,7 @@ The opt-in lives in `.sonarlint/sonar-local.props` (analyzer package) and `.sona
 | `Semantics.Music` | Immutable musical value types (`Pitch`, `Interval`, `Scale`, `Chord`, `Key`, `Duration`, `TimeSignature`) plus an analysis aggregate layer (`Progression`, `Section`, `Arrangement`, `Form`) computing roman numerals, cadences, key inference, chromatic identification, and named forms. Targets `net8.0`–`net10.0` + `netstandard2.0`/`netstandard2.1`. |
 | `Semantics.Color` | Physically-grounded color types. Canonical linear-RGB `Color` hub plus color-space satellites (`Srgb`, `Hsl`, `Hsv`, `Oklab`, `Oklch`); every type converts to and from every other, routed through the nearest shared hub (`Srgb` within the sRGB family, `Oklab` within the perceptual family, linear `Color` across families) so no conversion takes a redundant gamma round-trip. Also WCAG accessibility tooling, HSL/perceptual adjustment operations (lighten/saturate/hue/invert), and `NamedColors`. Targets `net8.0`–`net10.0` + `netstandard2.0`/`netstandard2.1`. |
 | `Semantics.Quantities` | Hand-written runtime types (`PhysicalQuantity<TSelf, T>`, `IVector0`..`IVector4`, `UnitSystem`) plus generator output under `Generated/`. |
-| `Semantics.SourceGenerators` | Roslyn incremental generators that emit quantity types, units, conversions, magnitudes, physical constants, and storage-type helpers from metadata. `CodeGen/` holds the parts that are not specific to physics — the metadata-driven generator base, metadata loading, the diagnostic catalogue — and is being extracted into a shared toolkit (#181). |
+| `Semantics.SourceGenerators` | Roslyn incremental generators that emit quantity types, units, conversions, magnitudes, physical constants, and storage-type helpers from metadata. The C# syntax templates now come from `ktsu.CodeBlocker.Templates`; `CodeGen/` holds what is left that is not specific to physics — the metadata-driven generator base, metadata loading, the diagnostic catalogue — and is being extracted into a shared toolkit (#181). |
 | `Semantics.Quantities.{Double,Float,Decimal}` | Props-only satellite packages. Each ships a `buildTransitive` props file (generated by `scripts/Generate-AliasProps.ps1`) that injects global-using aliases binding every quantity to one storage type, so consumers write `Mass` instead of `Mass<double>`. |
 | `Semantics.Test` | MSTest project covering all of the above. |
 
@@ -169,6 +169,8 @@ var converted = sourceString.As<SourceType, TargetType>();
 ### Working with the source generator
 
 - A generator declares the metadata files it reads via `MetadataFileNames` and derives from `SemanticsGenerator<T>` (one file) or `SemanticsMultiFileGenerator` (several). Neither needs to override `Initialize`.
+- Emitted C# is described with the template model from `ktsu.CodeBlocker.Templates` — `SourceFileTemplate`, `ClassTemplate`, `FieldTemplate`, `MethodTemplate` and friends. The model owns punctuation, spacing, member ordering and indentation, so a `BodyFactory` writes only the body: `=> Create(value);` for an expression body, or a braced block. Do **not** prefix it with a space; the model supplies the separator.
+- A type's declaration keyword comes from `ClassTemplate.Kind` (`TypeKind.Class`, `TypeKind.Record`, …), not from `Keywords`, which carries only modifiers. Collection properties are read-only, so use collection-initializer syntax (`Keywords = { "public" }`) rather than assignment, or the `WithComments`/`WithInterfaces` helpers when you already hold a sequence.
 - Edit `Semantics.SourceGenerators/Metadata/dimensions.json` to add a dimension, vector form, semantic overload, or relationship.
 - Rebuild `Semantics.SourceGenerators` and the consuming `Semantics.Quantities` project; emitted files appear in `Semantics.Quantities/Generated/Semantics.SourceGenerators/<GeneratorName>/`.
 - Treat generator output as committed source. Diff it before commit so accidental regressions are visible.
diff --git a/Directory.Packages.props b/Directory.Packages.props
index c15c7ba3..6e8776c1 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -14,7 +14,7 @@
     <PackageVersion Include="System.Threading.Tasks.Extensions" Version="4.6.3" />
     <PackageVersion Include="System.Numerics.Vectors" Version="4.6.1" />
     <!-- Source generator packages -->
-    <PackageVersion Include="ktsu.CodeBlocker" Version="1.2.16" />
+    <PackageVersion Include="ktsu.CodeBlocker" Version="1.3.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="5.9.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="5.9.0" />
     <!-- Build-time only: the generator reads its metadata with it. No shipping project
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.ConversionsGenerator/ConversionConstants.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.ConversionsGenerator/ConversionConstants.g.cs
index c8c94ea5..c08e3c1a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.ConversionsGenerator/ConversionConstants.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.ConversionsGenerator/ConversionConstants.g.cs
@@ -7,7 +7,8 @@ namespace ktsu.Semantics.Quantities.Units;
 /// Conversion constants used by generated unit definitions.
 /// Values sourced from conversions.json metadata.
 /// </summary>
-internal static class ConversionConstants{
+internal static class ConversionConstants
+{
 	/// <summary>Foot to meter conversion: 0.3048 m/ft (exact by definition)</summary>
 	internal const double FeetToMeters = 0.3048;
 
@@ -271,6 +272,5 @@ internal static class ConversionConstants{
 
 	/// <summary>Percent by weight to mass-fraction ratio: 0.01 (exact by definition)</summary>
 	internal const double PercentByWeightToRatio = 0.01;
-
-};
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.DimensionsGenerator/PhysicalDimensions.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.DimensionsGenerator/PhysicalDimensions.g.cs
index db5dfc6b..677df295 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.DimensionsGenerator/PhysicalDimensions.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.DimensionsGenerator/PhysicalDimensions.g.cs
@@ -8,12 +8,15 @@ namespace ktsu.Semantics.Quantities;
 /// <summary>
 /// Dimension information record.
 /// </summary>
-public record DimensionInfo(string Name, string Symbol, Dictionary<string, int> DimensionalFormula, List<string> Quantities){ }
+public record DimensionInfo(string Name, string Symbol, Dictionary<string, int> DimensionalFormula, List<string> Quantities)
+{
+}
 
 /// <summary>
 /// Static registry of physical dimensions.
 /// </summary>
-public static class PhysicalDimensions{
+public static class PhysicalDimensions
+{
 	/// <summary>Physical dimension: AbsorbedDose</summary>
 	public static readonly DimensionInfo AbsorbedDose = new("AbsorbedDose", "L² T⁻²", new Dictionary<string, int> { ["length"] = 2, ["time"] = -2 }, new List<string> { "AbsorbedDose" });
 
@@ -232,510 +235,581 @@ public static class PhysicalDimensions{
 
 	/// <summary>Gets a frozen collection of all standard physical dimensions.</summary>
 	public static IReadOnlySet<DimensionInfo> All = new HashSet<DimensionInfo>([ AbsorbedDose, Acceleration, AcousticImpedance, AmountOfSubstance, AngularAcceleration, AngularDisplacement, AngularJerk, AngularMomentum, AngularVelocity, Area, CatalyticActivity, Concentration, Density, Dimensionless, DynamicViscosity, ElectricCapacitance, ElectricCharge, ElectricConductance, ElectricConductivity, ElectricCurrent, ElectricField, ElectricFlux, ElectricPotential, ElectricPowerDensity, ElectricResistance, Energy, Entropy, EquivalentDose, Exposure, Force, Frequency, HeatTransferCoefficient, Illuminance, Inductance, Irradiance, Jerk, KinematicViscosity, Length, Loudness, Luminance, LuminousFlux, LuminousIntensity, MagneticFlux, MagneticFluxDensity, Mass, MassFlowRate, MolarEnergy, MolarMass, MomentOfInertia, Momentum, NuclearCrossSection, OpticalPower, Permittivity, Power, Pressure, RadioactiveActivity, RateConstant, ReactionRate, Sensitivity, Sharpness, Snap, SpecificHeat, SurfaceTension, Temperature, ThermalConductivity, ThermalExpansion, ThermalResistance, Time, Torque, Velocity, Volume, VolumetricFlowRate ]);
-
-};
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>AbsorbedDose</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IAbsorbedDoseUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Acceleration</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IAccelerationUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>AcousticImpedance</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IAcousticImpedanceUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>AmountOfSubstance</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IAmountOfSubstanceUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>AngularAcceleration</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IAngularAccelerationUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>AngularDisplacement</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IAngularDisplacementUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>AngularJerk</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IAngularJerkUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>AngularMomentum</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IAngularMomentumUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>AngularVelocity</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IAngularVelocityUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Area</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IAreaUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>CatalyticActivity</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface ICatalyticActivityUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Concentration</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IConcentrationUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Density</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IDensityUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Dimensionless</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IDimensionlessUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>DynamicViscosity</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IDynamicViscosityUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>ElectricCapacitance</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IElectricCapacitanceUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>ElectricCharge</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IElectricChargeUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>ElectricConductance</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IElectricConductanceUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>ElectricConductivity</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IElectricConductivityUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>ElectricCurrent</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IElectricCurrentUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>ElectricField</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IElectricFieldUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>ElectricFlux</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IElectricFluxUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>ElectricPotential</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IElectricPotentialUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>ElectricPowerDensity</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IElectricPowerDensityUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>ElectricResistance</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IElectricResistanceUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Energy</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IEnergyUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Entropy</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IEntropyUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>EquivalentDose</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IEquivalentDoseUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Exposure</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IExposureUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Force</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IForceUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Frequency</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IFrequencyUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>HeatTransferCoefficient</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IHeatTransferCoefficientUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Illuminance</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IIlluminanceUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Inductance</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IInductanceUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Irradiance</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IIrradianceUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Jerk</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IJerkUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>KinematicViscosity</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IKinematicViscosityUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Length</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface ILengthUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Loudness</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface ILoudnessUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Luminance</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface ILuminanceUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>LuminousFlux</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface ILuminousFluxUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>LuminousIntensity</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface ILuminousIntensityUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>MagneticFlux</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IMagneticFluxUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>MagneticFluxDensity</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IMagneticFluxDensityUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Mass</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IMassUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>MassFlowRate</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IMassFlowRateUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>MolarEnergy</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IMolarEnergyUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>MolarMass</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IMolarMassUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>MomentOfInertia</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IMomentOfInertiaUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Momentum</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IMomentumUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>NuclearCrossSection</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface INuclearCrossSectionUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>OpticalPower</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IOpticalPowerUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Permittivity</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IPermittivityUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Power</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IPowerUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Pressure</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IPressureUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>RadioactiveActivity</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IRadioactiveActivityUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>RateConstant</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IRateConstantUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>ReactionRate</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IReactionRateUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Sensitivity</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface ISensitivityUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Sharpness</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface ISharpnessUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Snap</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface ISnapUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>SpecificHeat</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface ISpecificHeatUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>SurfaceTension</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface ISurfaceTensionUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Temperature</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface ITemperatureUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>ThermalConductivity</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IThermalConductivityUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>ThermalExpansion</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IThermalExpansionUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>ThermalResistance</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IThermalResistanceUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Time</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface ITimeUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Torque</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface ITorqueUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Velocity</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IVelocityUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>Volume</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IVolumeUnit : IUnit
-{ }
+{
+}
 
 /// <summary>
 /// Marker interface implemented by every unit of the <c>VolumetricFlowRate</c> dimension.
 /// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.
 /// </summary>
 public interface IVolumetricFlowRateUnit : IUnit
-{ }
+{
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.MagnitudesGenerator/MetricMagnitudes.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.MagnitudesGenerator/MetricMagnitudes.g.cs
index 49452368..9fc0fd27 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.MagnitudesGenerator/MetricMagnitudes.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.MagnitudesGenerator/MetricMagnitudes.g.cs
@@ -6,7 +6,8 @@ namespace ktsu.Semantics.Quantities;
 /// <summary>
 /// Metric magnitude constants for unit scaling.
 /// </summary>
-public static class MetricMagnitudes{
+public static class MetricMagnitudes
+{
 	/// <summary>Yotta magnitude (Y): 10^24</summary>
 	public const double Yotta = 1e24;
 
@@ -69,6 +70,5 @@ public static class MetricMagnitudes{
 
 	/// <summary>Yocto magnitude (y): 10^-24</summary>
 	public const double Yocto = 1e-24;
-
-};
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.PhysicalConstantsGenerator/PhysicalConstants.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.PhysicalConstantsGenerator/PhysicalConstants.g.cs
index de442359..531ce96d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.PhysicalConstantsGenerator/PhysicalConstants.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.PhysicalConstantsGenerator/PhysicalConstants.g.cs
@@ -10,25 +10,30 @@ namespace ktsu.Semantics.Quantities;
 /// Provides fundamental physical constants used throughout the Semantics library.
 /// All values are based on the 2019 redefinition of SI base units and CODATA 2018 values.
 /// </summary>
-public static class PhysicalConstants{
-
+public static class PhysicalConstants
+{
 	/// <summary>
 	/// The physics of sound and vibration, including wave propagation, acoustic properties, sound intensity, frequency analysis, and audio-related measurements
 	/// </summary>
-	public static class Acoustics{
+	public static class Acoustics
+	{
 		/// <summary>Reference sound intensity: 1 × 10⁻¹² W/m² (threshold of hearing)</summary>
-		public static T ReferenceSoundIntensity<T>() where T : struct, INumber<T> => Values<T>.ReferenceSoundIntensity;
-/// <summary>Reference sound power: 1 × 10⁻¹² W</summary>
-		public static T ReferenceSoundPower<T>() where T : struct, INumber<T> => Values<T>.ReferenceSoundPower;
-/// <summary>Reference sound pressure: 20 × 10⁻⁶ Pa (threshold of hearing)</summary>
-		public static T ReferenceSoundPressure<T>() where T : struct, INumber<T> => Values<T>.ReferenceSoundPressure;
-/// <summary>Sabine reverberation constant: 0.161 s/m</summary>
-		public static T SabineConstant<T>() where T : struct, INumber<T> => Values<T>.SabineConstant;
+		public static T ReferenceSoundIntensity<T>()  where T : struct, INumber<T> => Values<T>.ReferenceSoundIntensity;
 
-/// <summary>
+		/// <summary>Reference sound power: 1 × 10⁻¹² W</summary>
+		public static T ReferenceSoundPower<T>()  where T : struct, INumber<T> => Values<T>.ReferenceSoundPower;
+
+		/// <summary>Reference sound pressure: 20 × 10⁻⁶ Pa (threshold of hearing)</summary>
+		public static T ReferenceSoundPressure<T>()  where T : struct, INumber<T> => Values<T>.ReferenceSoundPressure;
+
+		/// <summary>Sabine reverberation constant: 0.161 s/m</summary>
+		public static T SabineConstant<T>()  where T : struct, INumber<T> => Values<T>.SabineConstant;
+
+		/// <summary>
 		/// Caches the Acoustics constants materialised into <typeparamref name="T"/>.
 		/// </summary>
-		private static class Values<T>	where T : struct, INumber<T>
+		private static class Values<T>
+			where T : struct, INumber<T>
 		{
 			/// <summary>Reference sound intensity: 1 × 10⁻¹² W/m² (threshold of hearing)</summary>
 			internal static readonly T ReferenceSoundIntensity = T.Parse("1e-12", NumberStyles.Float, CultureInfo.InvariantCulture);
@@ -41,25 +46,28 @@ private static class Values<T>	where T : struct, INumber<T>
 
 			/// <summary>Sabine reverberation constant: 0.161 s/m</summary>
 			internal static readonly T SabineConstant = T.Parse("0.161", NumberStyles.Float, CultureInfo.InvariantCulture);
-
-		};
-	};
+		}
+	}
 
 	/// <summary>
 	/// Rotational motion and angular quantities, including angular velocity, angular acceleration, torque, and moment of inertia
 	/// </summary>
-	public static class AngularMechanics{
+	public static class AngularMechanics
+	{
 		/// <summary>Degrees per radian: 180/π ≈ 57.29577951308232</summary>
-		public static T DegreesPerRadian<T>() where T : struct, INumber<T> => Values<T>.DegreesPerRadian;
-/// <summary>Radians per degree: π/180 ≈ 0.017453292519943295</summary>
-		public static T RadiansPerDegree<T>() where T : struct, INumber<T> => Values<T>.RadiansPerDegree;
-/// <summary>2π - Full rotation in radians: 6.283185307179586</summary>
-		public static T TwoPi<T>() where T : struct, INumber<T> => Values<T>.TwoPi;
+		public static T DegreesPerRadian<T>()  where T : struct, INumber<T> => Values<T>.DegreesPerRadian;
 
-/// <summary>
+		/// <summary>Radians per degree: π/180 ≈ 0.017453292519943295</summary>
+		public static T RadiansPerDegree<T>()  where T : struct, INumber<T> => Values<T>.RadiansPerDegree;
+
+		/// <summary>2π - Full rotation in radians: 6.283185307179586</summary>
+		public static T TwoPi<T>()  where T : struct, INumber<T> => Values<T>.TwoPi;
+
+		/// <summary>
 		/// Caches the AngularMechanics constants materialised into <typeparamref name="T"/>.
 		/// </summary>
-		private static class Values<T>	where T : struct, INumber<T>
+		private static class Values<T>
+			where T : struct, INumber<T>
 		{
 			/// <summary>Degrees per radian: 180/π ≈ 57.29577951308232</summary>
 			internal static readonly T DegreesPerRadian = T.Parse("57.29577951308232087679815481410517033240547246656432154916024386120284714832155263244096899585111094418897585567892854596978524038074810298080734906", NumberStyles.Float, CultureInfo.InvariantCulture);
@@ -69,29 +77,34 @@ private static class Values<T>	where T : struct, INumber<T>
 
 			/// <summary>2π - Full rotation in radians: 6.283185307179586</summary>
 			internal static readonly T TwoPi = T.Parse("6.283185307179586476925286766559005768394338798750211641949889184615632812572417997256069650684234135964735462226659258240820374631042607435096896808248", NumberStyles.Float, CultureInfo.InvariantCulture);
-
-		};
-	};
+		}
+	}
 
 	/// <summary>
 	/// Chemical quantities and processes, including molecular properties, reaction kinetics, chemical concentrations, and the physical aspects of chemical systems
 	/// </summary>
-	public static class Chemistry{
+	public static class Chemistry
+	{
 		/// <summary>Gas constant: 8.31446261815324 J/(mol·K) (exact, derived from Avogadro and Boltzmann constants)</summary>
-		public static T GasConstant<T>() where T : struct, INumber<T> => Values<T>.GasConstant;
-/// <summary>Natural logarithm of 2: 0.6931471805599453</summary>
-		public static T Ln2<T>() where T : struct, INumber<T> => Values<T>.Ln2;
-/// <summary>Molar volume of ideal gas at STP: 22.413969545014137 L/mol (calculated from R*T/P at 273.15K, 101325Pa)</summary>
-		public static T MolarVolumeSTP<T>() where T : struct, INumber<T> => Values<T>.MolarVolumeSTP;
-/// <summary>Neutral pH value at 25°C: 7.0</summary>
-		public static T NeutralPH<T>() where T : struct, INumber<T> => Values<T>.NeutralPH;
-/// <summary>Water ion product (Kw) at 25°C: 1.0 × 10⁻¹⁴ (pKw = 14.0)</summary>
-		public static T WaterIonProduct<T>() where T : struct, INumber<T> => Values<T>.WaterIonProduct;
+		public static T GasConstant<T>()  where T : struct, INumber<T> => Values<T>.GasConstant;
 
-/// <summary>
+		/// <summary>Natural logarithm of 2: 0.6931471805599453</summary>
+		public static T Ln2<T>()  where T : struct, INumber<T> => Values<T>.Ln2;
+
+		/// <summary>Molar volume of ideal gas at STP: 22.413969545014137 L/mol (calculated from R*T/P at 273.15K, 101325Pa)</summary>
+		public static T MolarVolumeSTP<T>()  where T : struct, INumber<T> => Values<T>.MolarVolumeSTP;
+
+		/// <summary>Neutral pH value at 25°C: 7.0</summary>
+		public static T NeutralPH<T>()  where T : struct, INumber<T> => Values<T>.NeutralPH;
+
+		/// <summary>Water ion product (Kw) at 25°C: 1.0 × 10⁻¹⁴ (pKw = 14.0)</summary>
+		public static T WaterIonProduct<T>()  where T : struct, INumber<T> => Values<T>.WaterIonProduct;
+
+		/// <summary>
 		/// Caches the Chemistry constants materialised into <typeparamref name="T"/>.
 		/// </summary>
-		private static class Values<T>	where T : struct, INumber<T>
+		private static class Values<T>
+			where T : struct, INumber<T>
 		{
 			/// <summary>Gas constant: 8.31446261815324 J/(mol·K) (exact, derived from Avogadro and Boltzmann constants)</summary>
 			internal static readonly T GasConstant = T.Parse("8.31446261815324", NumberStyles.Float, CultureInfo.InvariantCulture);
@@ -107,83 +120,96 @@ private static class Values<T>	where T : struct, INumber<T>
 
 			/// <summary>Water ion product (Kw) at 25°C: 1.0 × 10⁻¹⁴ (pKw = 14.0)</summary>
 			internal static readonly T WaterIonProduct = T.Parse("14.0", NumberStyles.Float, CultureInfo.InvariantCulture);
-
-		};
-	};
+		}
+	}
 
 	/// <summary>
 	/// The physics of motion for macroscopic objects, covering forces, momentum, energy, rotational dynamics, and the motion of particles and rigid bodies
 	/// </summary>
-	public static class ClassicalMechanics{
+	public static class ClassicalMechanics
+	{
 		/// <summary>Standard atmospheric pressure: 101,325 Pa (exact by definition)</summary>
-		public static T StandardAtmosphericPressure<T>() where T : struct, INumber<T> => Values<T>.StandardAtmosphericPressure;
-/// <summary>Standard gravitational acceleration: 9.80665 m/s² (exact by definition)</summary>
-		public static T StandardGravity<T>() where T : struct, INumber<T> => Values<T>.StandardGravity;
+		public static T StandardAtmosphericPressure<T>()  where T : struct, INumber<T> => Values<T>.StandardAtmosphericPressure;
 
-/// <summary>
+		/// <summary>Standard gravitational acceleration: 9.80665 m/s² (exact by definition)</summary>
+		public static T StandardGravity<T>()  where T : struct, INumber<T> => Values<T>.StandardGravity;
+
+		/// <summary>
 		/// Caches the ClassicalMechanics constants materialised into <typeparamref name="T"/>.
 		/// </summary>
-		private static class Values<T>	where T : struct, INumber<T>
+		private static class Values<T>
+			where T : struct, INumber<T>
 		{
 			/// <summary>Standard atmospheric pressure: 101,325 Pa (exact by definition)</summary>
 			internal static readonly T StandardAtmosphericPressure = T.Parse("101325", NumberStyles.Float, CultureInfo.InvariantCulture);
 
 			/// <summary>Standard gravitational acceleration: 9.80665 m/s² (exact by definition)</summary>
 			internal static readonly T StandardGravity = T.Parse("9.80665", NumberStyles.Float, CultureInfo.InvariantCulture);
-
-		};
-	};
+		}
+	}
 
 	/// <summary>
 	/// The study of fluids (liquids and gases) in motion and at rest, including fluid properties, flow dynamics, viscosity, pressure, and fluid-structure interactions
 	/// </summary>
-	public static class FluidMechanics{
+	public static class FluidMechanics
+	{
 		/// <summary>Standard air density at 15°C and 1 atm: 1.225 kg/m³ (ISO 2533)</summary>
-		public static T StandardAirDensity<T>() where T : struct, INumber<T> => Values<T>.StandardAirDensity;
-/// <summary>Water surface tension at 20°C: 0.0728 N/m (NIST)</summary>
-		public static T WaterSurfaceTension<T>() where T : struct, INumber<T> => Values<T>.WaterSurfaceTension;
+		public static T StandardAirDensity<T>()  where T : struct, INumber<T> => Values<T>.StandardAirDensity;
 
-/// <summary>
+		/// <summary>Water surface tension at 20°C: 0.0728 N/m (NIST)</summary>
+		public static T WaterSurfaceTension<T>()  where T : struct, INumber<T> => Values<T>.WaterSurfaceTension;
+
+		/// <summary>
 		/// Caches the FluidMechanics constants materialised into <typeparamref name="T"/>.
 		/// </summary>
-		private static class Values<T>	where T : struct, INumber<T>
+		private static class Values<T>
+			where T : struct, INumber<T>
 		{
 			/// <summary>Standard air density at 15°C and 1 atm: 1.225 kg/m³ (ISO 2533)</summary>
 			internal static readonly T StandardAirDensity = T.Parse("1.225", NumberStyles.Float, CultureInfo.InvariantCulture);
 
 			/// <summary>Water surface tension at 20°C: 0.0728 N/m (NIST)</summary>
 			internal static readonly T WaterSurfaceTension = T.Parse("0.0728", NumberStyles.Float, CultureInfo.InvariantCulture);
-
-		};
-	};
+		}
+	}
 
 	/// <summary>
 	/// Basic physical quantities and constants that form the foundation of all other physics domains, including fundamental units like length, mass, time, and universal constants
 	/// </summary>
-	public static class Fundamental{
+	public static class Fundamental
+	{
 		/// <summary>Avogadro's number: 6.02214076 × 10²³ entities/mol (exact, SI defining constant)</summary>
-		public static T AvogadroNumber<T>() where T : struct, INumber<T> => Values<T>.AvogadroNumber;
-/// <summary>Boltzmann constant: 1.380649 × 10⁻²³ J/K (exact, SI defining constant)</summary>
-		public static T BoltzmannConstant<T>() where T : struct, INumber<T> => Values<T>.BoltzmannConstant;
-/// <summary>Elementary charge: 1.602176634 × 10⁻¹⁹ C (exact, SI defining constant)</summary>
-		public static T ElementaryCharge<T>() where T : struct, INumber<T> => Values<T>.ElementaryCharge;
-/// <summary>Fine structure constant: 7.2973525693 × 10⁻³ (dimensionless, 2018 CODATA)</summary>
-		public static T FineStructureConstant<T>() where T : struct, INumber<T> => Values<T>.FineStructureConstant;
-/// <summary>Gravitational constant: 6.67430 × 10⁻¹¹ m³/(kg⋅s²) (2018 CODATA)</summary>
-		public static T GravitationalConstant<T>() where T : struct, INumber<T> => Values<T>.GravitationalConstant;
-/// <summary>Magnetic permeability of free space: 4π × 10⁻⁷ H/m (exact by definition)</summary>
-		public static T PermeabilityOfFreeSpace<T>() where T : struct, INumber<T> => Values<T>.PermeabilityOfFreeSpace;
-/// <summary>Electric permittivity of free space: 8.8541878128 × 10⁻¹² F/m (exact, derived)</summary>
-		public static T PermittivityOfFreeSpace<T>() where T : struct, INumber<T> => Values<T>.PermittivityOfFreeSpace;
-/// <summary>Planck constant: 6.62607015 × 10⁻³⁴ J·s (exact, SI defining constant)</summary>
-		public static T PlanckConstant<T>() where T : struct, INumber<T> => Values<T>.PlanckConstant;
-/// <summary>Speed of light in vacuum: 299,792,458 m/s (exact, SI defining constant)</summary>
-		public static T SpeedOfLight<T>() where T : struct, INumber<T> => Values<T>.SpeedOfLight;
+		public static T AvogadroNumber<T>()  where T : struct, INumber<T> => Values<T>.AvogadroNumber;
 
-/// <summary>
+		/// <summary>Boltzmann constant: 1.380649 × 10⁻²³ J/K (exact, SI defining constant)</summary>
+		public static T BoltzmannConstant<T>()  where T : struct, INumber<T> => Values<T>.BoltzmannConstant;
+
+		/// <summary>Elementary charge: 1.602176634 × 10⁻¹⁹ C (exact, SI defining constant)</summary>
+		public static T ElementaryCharge<T>()  where T : struct, INumber<T> => Values<T>.ElementaryCharge;
+
+		/// <summary>Fine structure constant: 7.2973525693 × 10⁻³ (dimensionless, 2018 CODATA)</summary>
+		public static T FineStructureConstant<T>()  where T : struct, INumber<T> => Values<T>.FineStructureConstant;
+
+		/// <summary>Gravitational constant: 6.67430 × 10⁻¹¹ m³/(kg⋅s²) (2018 CODATA)</summary>
+		public static T GravitationalConstant<T>()  where T : struct, INumber<T> => Values<T>.GravitationalConstant;
+
+		/// <summary>Magnetic permeability of free space: 4π × 10⁻⁷ H/m (exact by definition)</summary>
+		public static T PermeabilityOfFreeSpace<T>()  where T : struct, INumber<T> => Values<T>.PermeabilityOfFreeSpace;
+
+		/// <summary>Electric permittivity of free space: 8.8541878128 × 10⁻¹² F/m (exact, derived)</summary>
+		public static T PermittivityOfFreeSpace<T>()  where T : struct, INumber<T> => Values<T>.PermittivityOfFreeSpace;
+
+		/// <summary>Planck constant: 6.62607015 × 10⁻³⁴ J·s (exact, SI defining constant)</summary>
+		public static T PlanckConstant<T>()  where T : struct, INumber<T> => Values<T>.PlanckConstant;
+
+		/// <summary>Speed of light in vacuum: 299,792,458 m/s (exact, SI defining constant)</summary>
+		public static T SpeedOfLight<T>()  where T : struct, INumber<T> => Values<T>.SpeedOfLight;
+
+		/// <summary>
 		/// Caches the Fundamental constants materialised into <typeparamref name="T"/>.
 		/// </summary>
-		private static class Values<T>	where T : struct, INumber<T>
+		private static class Values<T>
+			where T : struct, INumber<T>
 		{
 			/// <summary>Avogadro's number: 6.02214076 × 10²³ entities/mol (exact, SI defining constant)</summary>
 			internal static readonly T AvogadroNumber = T.Parse("6.02214076e23", NumberStyles.Float, CultureInfo.InvariantCulture);
@@ -211,68 +237,75 @@ private static class Values<T>	where T : struct, INumber<T>
 
 			/// <summary>Speed of light in vacuum: 299,792,458 m/s (exact, SI defining constant)</summary>
 			internal static readonly T SpeedOfLight = T.Parse("299792458", NumberStyles.Float, CultureInfo.InvariantCulture);
-
-		};
-	};
+		}
+	}
 
 	/// <summary>
 	/// The study of atomic nuclei, radioactivity, nuclear reactions, decay processes, and radiation interactions with matter
 	/// </summary>
-	public static class NuclearPhysics{
+	public static class NuclearPhysics
+	{
 		/// <summary>Atomic mass unit: 1.66053906660 × 10⁻²⁷ kg (2018 CODATA)</summary>
-		public static T AtomicMassUnit<T>() where T : struct, INumber<T> => Values<T>.AtomicMassUnit;
-/// <summary>Nuclear magneton: 5.0507837461 × 10⁻²⁷ J/T (2018 CODATA)</summary>
-		public static T NuclearMagneton<T>() where T : struct, INumber<T> => Values<T>.NuclearMagneton;
+		public static T AtomicMassUnit<T>()  where T : struct, INumber<T> => Values<T>.AtomicMassUnit;
 
-/// <summary>
+		/// <summary>Nuclear magneton: 5.0507837461 × 10⁻²⁷ J/T (2018 CODATA)</summary>
+		public static T NuclearMagneton<T>()  where T : struct, INumber<T> => Values<T>.NuclearMagneton;
+
+		/// <summary>
 		/// Caches the NuclearPhysics constants materialised into <typeparamref name="T"/>.
 		/// </summary>
-		private static class Values<T>	where T : struct, INumber<T>
+		private static class Values<T>
+			where T : struct, INumber<T>
 		{
 			/// <summary>Atomic mass unit: 1.66053906660 × 10⁻²⁷ kg (2018 CODATA)</summary>
 			internal static readonly T AtomicMassUnit = T.Parse("1.66053906660e-27", NumberStyles.Float, CultureInfo.InvariantCulture);
 
 			/// <summary>Nuclear magneton: 5.0507837461 × 10⁻²⁷ J/T (2018 CODATA)</summary>
 			internal static readonly T NuclearMagneton = T.Parse("5.0507837461e-27", NumberStyles.Float, CultureInfo.InvariantCulture);
-
-		};
-	};
+		}
+	}
 
 	/// <summary>
 	/// The physics of light and optical phenomena, including electromagnetic radiation, photometry, illumination, optical properties, and light-matter interactions
 	/// </summary>
-	public static class Optics{
+	public static class Optics
+	{
 		/// <summary>Luminous efficacy of monochromatic radiation at 540 THz: 683 lm/W (exact, SI defining constant)</summary>
-		public static T LuminousEfficacy<T>() where T : struct, INumber<T> => Values<T>.LuminousEfficacy;
+		public static T LuminousEfficacy<T>()  where T : struct, INumber<T> => Values<T>.LuminousEfficacy;
 
-/// <summary>
+		/// <summary>
 		/// Caches the Optics constants materialised into <typeparamref name="T"/>.
 		/// </summary>
-		private static class Values<T>	where T : struct, INumber<T>
+		private static class Values<T>
+			where T : struct, INumber<T>
 		{
 			/// <summary>Luminous efficacy of monochromatic radiation at 540 THz: 683 lm/W (exact, SI defining constant)</summary>
 			internal static readonly T LuminousEfficacy = T.Parse("683.0", NumberStyles.Float, CultureInfo.InvariantCulture);
-
-		};
-	};
+		}
+	}
 
 	/// <summary>
 	/// The physics of heat, temperature, and energy transfer, including thermal properties, heat capacity, entropy, and thermodynamic processes
 	/// </summary>
-	public static class Thermodynamics{
+	public static class Thermodynamics
+	{
 		/// <summary>Absolute zero in Celsius: 273.15 K (exact by definition)</summary>
-		public static T AbsoluteZeroInCelsius<T>() where T : struct, INumber<T> => Values<T>.AbsoluteZeroInCelsius;
-/// <summary>Standard temperature (STP): 273.15 K (0°C)</summary>
-		public static T StandardTemperature<T>() where T : struct, INumber<T> => Values<T>.StandardTemperature;
-/// <summary>Water boiling point at 1 atm: 373.15 K (100°C)</summary>
-		public static T WaterBoilingPoint<T>() where T : struct, INumber<T> => Values<T>.WaterBoilingPoint;
-/// <summary>Water triple point: 273.16 K (exact by definition)</summary>
-		public static T WaterTriplePoint<T>() where T : struct, INumber<T> => Values<T>.WaterTriplePoint;
+		public static T AbsoluteZeroInCelsius<T>()  where T : struct, INumber<T> => Values<T>.AbsoluteZeroInCelsius;
 
-/// <summary>
+		/// <summary>Standard temperature (STP): 273.15 K (0°C)</summary>
+		public static T StandardTemperature<T>()  where T : struct, INumber<T> => Values<T>.StandardTemperature;
+
+		/// <summary>Water boiling point at 1 atm: 373.15 K (100°C)</summary>
+		public static T WaterBoilingPoint<T>()  where T : struct, INumber<T> => Values<T>.WaterBoilingPoint;
+
+		/// <summary>Water triple point: 273.16 K (exact by definition)</summary>
+		public static T WaterTriplePoint<T>()  where T : struct, INumber<T> => Values<T>.WaterTriplePoint;
+
+		/// <summary>
 		/// Caches the Thermodynamics constants materialised into <typeparamref name="T"/>.
 		/// </summary>
-		private static class Values<T>	where T : struct, INumber<T>
+		private static class Values<T>
+			where T : struct, INumber<T>
 		{
 			/// <summary>Absolute zero in Celsius: 273.15 K (exact by definition)</summary>
 			internal static readonly T AbsoluteZeroInCelsius = T.Parse("273.15", NumberStyles.Float, CultureInfo.InvariantCulture);
@@ -285,78 +318,109 @@ private static class Values<T>	where T : struct, INumber<T>
 
 			/// <summary>Water triple point: 273.16 K (exact by definition)</summary>
 			internal static readonly T WaterTriplePoint = T.Parse("273.16", NumberStyles.Float, CultureInfo.InvariantCulture);
-
-		};
-	};
+		}
+	}
 
 	/// <summary>
 	/// Helper methods to get constants as generic numeric types.
 	/// </summary>
-	public static class Generic{
+	public static class Generic
+	{
 		/// <summary>Gets absolute zero in celsius: 273.15 k (exact by definition) as type T.</summary>
-		public static T AbsoluteZeroInCelsius<T>() where T : struct, INumber<T> => Thermodynamics.AbsoluteZeroInCelsius<T>();
-/// <summary>Gets atomic mass unit: 1.66053906660 × 10⁻²⁷ kg (2018 codata) as type T.</summary>
-		public static T AtomicMassUnit<T>() where T : struct, INumber<T> => NuclearPhysics.AtomicMassUnit<T>();
-/// <summary>Gets avogadro's number: 6.02214076 × 10²³ entities/mol (exact, si defining constant) as type T.</summary>
-		public static T AvogadroNumber<T>() where T : struct, INumber<T> => Fundamental.AvogadroNumber<T>();
-/// <summary>Gets boltzmann constant: 1.380649 × 10⁻²³ j/k (exact, si defining constant) as type T.</summary>
-		public static T BoltzmannConstant<T>() where T : struct, INumber<T> => Fundamental.BoltzmannConstant<T>();
-/// <summary>Gets degrees per radian: 180/π ≈ 57.29577951308232 as type T.</summary>
-		public static T DegreesPerRadian<T>() where T : struct, INumber<T> => AngularMechanics.DegreesPerRadian<T>();
-/// <summary>Gets elementary charge: 1.602176634 × 10⁻¹⁹ c (exact, si defining constant) as type T.</summary>
-		public static T ElementaryCharge<T>() where T : struct, INumber<T> => Fundamental.ElementaryCharge<T>();
-/// <summary>Gets fine structure constant: 7.2973525693 × 10⁻³ (dimensionless, 2018 codata) as type T.</summary>
-		public static T FineStructureConstant<T>() where T : struct, INumber<T> => Fundamental.FineStructureConstant<T>();
-/// <summary>Gets gas constant: 8.31446261815324 j/(mol·k) (exact, derived from avogadro and boltzmann constants) as type T.</summary>
-		public static T GasConstant<T>() where T : struct, INumber<T> => Chemistry.GasConstant<T>();
-/// <summary>Gets gravitational constant: 6.67430 × 10⁻¹¹ m³/(kg⋅s²) (2018 codata) as type T.</summary>
-		public static T GravitationalConstant<T>() where T : struct, INumber<T> => Fundamental.GravitationalConstant<T>();
-/// <summary>Gets natural logarithm of 2: 0.6931471805599453 as type T.</summary>
-		public static T Ln2<T>() where T : struct, INumber<T> => Chemistry.Ln2<T>();
-/// <summary>Gets luminous efficacy of monochromatic radiation at 540 thz: 683 lm/w (exact, si defining constant) as type T.</summary>
-		public static T LuminousEfficacy<T>() where T : struct, INumber<T> => Optics.LuminousEfficacy<T>();
-/// <summary>Gets molar volume of ideal gas at stp: 22.413969545014137 l/mol (calculated from r*t/p at 273.15k, 101325pa) as type T.</summary>
-		public static T MolarVolumeSTP<T>() where T : struct, INumber<T> => Chemistry.MolarVolumeSTP<T>();
-/// <summary>Gets neutral ph value at 25°c: 7.0 as type T.</summary>
-		public static T NeutralPH<T>() where T : struct, INumber<T> => Chemistry.NeutralPH<T>();
-/// <summary>Gets nuclear magneton: 5.0507837461 × 10⁻²⁷ j/t (2018 codata) as type T.</summary>
-		public static T NuclearMagneton<T>() where T : struct, INumber<T> => NuclearPhysics.NuclearMagneton<T>();
-/// <summary>Gets magnetic permeability of free space: 4π × 10⁻⁷ h/m (exact by definition) as type T.</summary>
-		public static T PermeabilityOfFreeSpace<T>() where T : struct, INumber<T> => Fundamental.PermeabilityOfFreeSpace<T>();
-/// <summary>Gets electric permittivity of free space: 8.8541878128 × 10⁻¹² f/m (exact, derived) as type T.</summary>
-		public static T PermittivityOfFreeSpace<T>() where T : struct, INumber<T> => Fundamental.PermittivityOfFreeSpace<T>();
-/// <summary>Gets planck constant: 6.62607015 × 10⁻³⁴ j·s (exact, si defining constant) as type T.</summary>
-		public static T PlanckConstant<T>() where T : struct, INumber<T> => Fundamental.PlanckConstant<T>();
-/// <summary>Gets radians per degree: π/180 ≈ 0.017453292519943295 as type T.</summary>
-		public static T RadiansPerDegree<T>() where T : struct, INumber<T> => AngularMechanics.RadiansPerDegree<T>();
-/// <summary>Gets reference sound intensity: 1 × 10⁻¹² w/m² (threshold of hearing) as type T.</summary>
-		public static T ReferenceSoundIntensity<T>() where T : struct, INumber<T> => Acoustics.ReferenceSoundIntensity<T>();
-/// <summary>Gets reference sound power: 1 × 10⁻¹² w as type T.</summary>
-		public static T ReferenceSoundPower<T>() where T : struct, INumber<T> => Acoustics.ReferenceSoundPower<T>();
-/// <summary>Gets reference sound pressure: 20 × 10⁻⁶ pa (threshold of hearing) as type T.</summary>
-		public static T ReferenceSoundPressure<T>() where T : struct, INumber<T> => Acoustics.ReferenceSoundPressure<T>();
-/// <summary>Gets sabine reverberation constant: 0.161 s/m as type T.</summary>
-		public static T SabineConstant<T>() where T : struct, INumber<T> => Acoustics.SabineConstant<T>();
-/// <summary>Gets speed of light in vacuum: 299,792,458 m/s (exact, si defining constant) as type T.</summary>
-		public static T SpeedOfLight<T>() where T : struct, INumber<T> => Fundamental.SpeedOfLight<T>();
-/// <summary>Gets standard air density at 15°c and 1 atm: 1.225 kg/m³ (iso 2533) as type T.</summary>
-		public static T StandardAirDensity<T>() where T : struct, INumber<T> => FluidMechanics.StandardAirDensity<T>();
-/// <summary>Gets standard atmospheric pressure: 101,325 pa (exact by definition) as type T.</summary>
-		public static T StandardAtmosphericPressure<T>() where T : struct, INumber<T> => ClassicalMechanics.StandardAtmosphericPressure<T>();
-/// <summary>Gets standard gravitational acceleration: 9.80665 m/s² (exact by definition) as type T.</summary>
-		public static T StandardGravity<T>() where T : struct, INumber<T> => ClassicalMechanics.StandardGravity<T>();
-/// <summary>Gets standard temperature (stp): 273.15 k (0°c) as type T.</summary>
-		public static T StandardTemperature<T>() where T : struct, INumber<T> => Thermodynamics.StandardTemperature<T>();
-/// <summary>Gets 2π - full rotation in radians: 6.283185307179586 as type T.</summary>
-		public static T TwoPi<T>() where T : struct, INumber<T> => AngularMechanics.TwoPi<T>();
-/// <summary>Gets water boiling point at 1 atm: 373.15 k (100°c) as type T.</summary>
-		public static T WaterBoilingPoint<T>() where T : struct, INumber<T> => Thermodynamics.WaterBoilingPoint<T>();
-/// <summary>Gets water ion product (kw) at 25°c: 1.0 × 10⁻¹⁴ (pkw = 14.0) as type T.</summary>
-		public static T WaterIonProduct<T>() where T : struct, INumber<T> => Chemistry.WaterIonProduct<T>();
-/// <summary>Gets water surface tension at 20°c: 0.0728 n/m (nist) as type T.</summary>
-		public static T WaterSurfaceTension<T>() where T : struct, INumber<T> => FluidMechanics.WaterSurfaceTension<T>();
-/// <summary>Gets water triple point: 273.16 k (exact by definition) as type T.</summary>
-		public static T WaterTriplePoint<T>() where T : struct, INumber<T> => Thermodynamics.WaterTriplePoint<T>();
-};
-};
+		public static T AbsoluteZeroInCelsius<T>()  where T : struct, INumber<T> => Thermodynamics.AbsoluteZeroInCelsius<T>();
+
+		/// <summary>Gets atomic mass unit: 1.66053906660 × 10⁻²⁷ kg (2018 codata) as type T.</summary>
+		public static T AtomicMassUnit<T>()  where T : struct, INumber<T> => NuclearPhysics.AtomicMassUnit<T>();
+
+		/// <summary>Gets avogadro's number: 6.02214076 × 10²³ entities/mol (exact, si defining constant) as type T.</summary>
+		public static T AvogadroNumber<T>()  where T : struct, INumber<T> => Fundamental.AvogadroNumber<T>();
+
+		/// <summary>Gets boltzmann constant: 1.380649 × 10⁻²³ j/k (exact, si defining constant) as type T.</summary>
+		public static T BoltzmannConstant<T>()  where T : struct, INumber<T> => Fundamental.BoltzmannConstant<T>();
+
+		/// <summary>Gets degrees per radian: 180/π ≈ 57.29577951308232 as type T.</summary>
+		public static T DegreesPerRadian<T>()  where T : struct, INumber<T> => AngularMechanics.DegreesPerRadian<T>();
+
+		/// <summary>Gets elementary charge: 1.602176634 × 10⁻¹⁹ c (exact, si defining constant) as type T.</summary>
+		public static T ElementaryCharge<T>()  where T : struct, INumber<T> => Fundamental.ElementaryCharge<T>();
+
+		/// <summary>Gets fine structure constant: 7.2973525693 × 10⁻³ (dimensionless, 2018 codata) as type T.</summary>
+		public static T FineStructureConstant<T>()  where T : struct, INumber<T> => Fundamental.FineStructureConstant<T>();
+
+		/// <summary>Gets gas constant: 8.31446261815324 j/(mol·k) (exact, derived from avogadro and boltzmann constants) as type T.</summary>
+		public static T GasConstant<T>()  where T : struct, INumber<T> => Chemistry.GasConstant<T>();
+
+		/// <summary>Gets gravitational constant: 6.67430 × 10⁻¹¹ m³/(kg⋅s²) (2018 codata) as type T.</summary>
+		public static T GravitationalConstant<T>()  where T : struct, INumber<T> => Fundamental.GravitationalConstant<T>();
+
+		/// <summary>Gets natural logarithm of 2: 0.6931471805599453 as type T.</summary>
+		public static T Ln2<T>()  where T : struct, INumber<T> => Chemistry.Ln2<T>();
+
+		/// <summary>Gets luminous efficacy of monochromatic radiation at 540 thz: 683 lm/w (exact, si defining constant) as type T.</summary>
+		public static T LuminousEfficacy<T>()  where T : struct, INumber<T> => Optics.LuminousEfficacy<T>();
+
+		/// <summary>Gets molar volume of ideal gas at stp: 22.413969545014137 l/mol (calculated from r*t/p at 273.15k, 101325pa) as type T.</summary>
+		public static T MolarVolumeSTP<T>()  where T : struct, INumber<T> => Chemistry.MolarVolumeSTP<T>();
+
+		/// <summary>Gets neutral ph value at 25°c: 7.0 as type T.</summary>
+		public static T NeutralPH<T>()  where T : struct, INumber<T> => Chemistry.NeutralPH<T>();
+
+		/// <summary>Gets nuclear magneton: 5.0507837461 × 10⁻²⁷ j/t (2018 codata) as type T.</summary>
+		public static T NuclearMagneton<T>()  where T : struct, INumber<T> => NuclearPhysics.NuclearMagneton<T>();
+
+		/// <summary>Gets magnetic permeability of free space: 4π × 10⁻⁷ h/m (exact by definition) as type T.</summary>
+		public static T PermeabilityOfFreeSpace<T>()  where T : struct, INumber<T> => Fundamental.PermeabilityOfFreeSpace<T>();
+
+		/// <summary>Gets electric permittivity of free space: 8.8541878128 × 10⁻¹² f/m (exact, derived) as type T.</summary>
+		public static T PermittivityOfFreeSpace<T>()  where T : struct, INumber<T> => Fundamental.PermittivityOfFreeSpace<T>();
+
+		/// <summary>Gets planck constant: 6.62607015 × 10⁻³⁴ j·s (exact, si defining constant) as type T.</summary>
+		public static T PlanckConstant<T>()  where T : struct, INumber<T> => Fundamental.PlanckConstant<T>();
+
+		/// <summary>Gets radians per degree: π/180 ≈ 0.017453292519943295 as type T.</summary>
+		public static T RadiansPerDegree<T>()  where T : struct, INumber<T> => AngularMechanics.RadiansPerDegree<T>();
+
+		/// <summary>Gets reference sound intensity: 1 × 10⁻¹² w/m² (threshold of hearing) as type T.</summary>
+		public static T ReferenceSoundIntensity<T>()  where T : struct, INumber<T> => Acoustics.ReferenceSoundIntensity<T>();
+
+		/// <summary>Gets reference sound power: 1 × 10⁻¹² w as type T.</summary>
+		public static T ReferenceSoundPower<T>()  where T : struct, INumber<T> => Acoustics.ReferenceSoundPower<T>();
+
+		/// <summary>Gets reference sound pressure: 20 × 10⁻⁶ pa (threshold of hearing) as type T.</summary>
+		public static T ReferenceSoundPressure<T>()  where T : struct, INumber<T> => Acoustics.ReferenceSoundPressure<T>();
+
+		/// <summary>Gets sabine reverberation constant: 0.161 s/m as type T.</summary>
+		public static T SabineConstant<T>()  where T : struct, INumber<T> => Acoustics.SabineConstant<T>();
+
+		/// <summary>Gets speed of light in vacuum: 299,792,458 m/s (exact, si defining constant) as type T.</summary>
+		public static T SpeedOfLight<T>()  where T : struct, INumber<T> => Fundamental.SpeedOfLight<T>();
+
+		/// <summary>Gets standard air density at 15°c and 1 atm: 1.225 kg/m³ (iso 2533) as type T.</summary>
+		public static T StandardAirDensity<T>()  where T : struct, INumber<T> => FluidMechanics.StandardAirDensity<T>();
+
+		/// <summary>Gets standard atmospheric pressure: 101,325 pa (exact by definition) as type T.</summary>
+		public static T StandardAtmosphericPressure<T>()  where T : struct, INumber<T> => ClassicalMechanics.StandardAtmosphericPressure<T>();
+
+		/// <summary>Gets standard gravitational acceleration: 9.80665 m/s² (exact by definition) as type T.</summary>
+		public static T StandardGravity<T>()  where T : struct, INumber<T> => ClassicalMechanics.StandardGravity<T>();
+
+		/// <summary>Gets standard temperature (stp): 273.15 k (0°c) as type T.</summary>
+		public static T StandardTemperature<T>()  where T : struct, INumber<T> => Thermodynamics.StandardTemperature<T>();
+
+		/// <summary>Gets 2π - full rotation in radians: 6.283185307179586 as type T.</summary>
+		public static T TwoPi<T>()  where T : struct, INumber<T> => AngularMechanics.TwoPi<T>();
+
+		/// <summary>Gets water boiling point at 1 atm: 373.15 k (100°c) as type T.</summary>
+		public static T WaterBoilingPoint<T>()  where T : struct, INumber<T> => Thermodynamics.WaterBoilingPoint<T>();
+
+		/// <summary>Gets water ion product (kw) at 25°c: 1.0 × 10⁻¹⁴ (pkw = 14.0) as type T.</summary>
+		public static T WaterIonProduct<T>()  where T : struct, INumber<T> => Chemistry.WaterIonProduct<T>();
+
+		/// <summary>Gets water surface tension at 20°c: 0.0728 n/m (nist) as type T.</summary>
+		public static T WaterSurfaceTension<T>()  where T : struct, INumber<T> => FluidMechanics.WaterSurfaceTension<T>();
+
+		/// <summary>Gets water triple point: 273.16 k (exact by definition) as type T.</summary>
+		public static T WaterTriplePoint<T>()  where T : struct, INumber<T> => Thermodynamics.WaterTriplePoint<T>();
+	}
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.PrecisionGenerator/StorageTypes.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.PrecisionGenerator/StorageTypes.g.cs
index d6f43227..4a908035 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.PrecisionGenerator/StorageTypes.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.PrecisionGenerator/StorageTypes.g.cs
@@ -9,7 +9,8 @@ namespace ktsu.Semantics.Quantities;
 /// <summary>
 /// Available storage types for numeric values in the Semantics library.
 /// </summary>
-public static class StorageTypes{
+public static class StorageTypes
+{
 	/// <summary>The double storage type.</summary>
 	public static readonly Type DOUBLE = typeof(double);
 
@@ -21,6 +22,5 @@ public static class StorageTypes{
 
 	/// <summary>Gets the names of all available storage types.</summary>
 	public static readonly IReadOnlyList<string> Names = new List<string> { "double", "float" };
-
-};
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AbsorbedDose.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AbsorbedDose.g.cs
index fa10570f..b5b671de 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AbsorbedDose.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AbsorbedDose.g.cs
@@ -25,24 +25,28 @@ public partial record AbsorbedDose<T> : PhysicalQuantity<AbsorbedDose<T>, T>, IV
 	/// <returns>A new <see cref="AbsorbedDose{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AbsorbedDose<T> FromGray(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="AbsorbedDose{T}"/> from a value in Rad.
 	/// </summary>
 	/// <param name="value">The value in Rad.</param>
 	/// <returns>A new <see cref="AbsorbedDose{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AbsorbedDose<T> FromRad(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.RadToGrays)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AbsorbedDose unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAbsorbedDoseUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two AbsorbedDose values, returning the absolute difference as a non-negative AbsorbedDose.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AbsorbedDose<T> operator -(AbsorbedDose<T> left, AbsorbedDose<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AbsorbedDose<T> operator -(AbsorbedDose<T> left, AbsorbedDose<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration1D.g.cs
index 7f9532da..10cb7301 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration1D.g.cs
@@ -24,31 +24,38 @@ public partial record Acceleration1D<T> : PhysicalQuantity<Acceleration1D<T>, T>
 	/// <param name="value">The value in MeterPerSecondSquared.</param>
 	/// <returns>A new <see cref="Acceleration1D{T}"/> instance.</returns>
 	public static Acceleration1D<T> FromMeterPerSecondSquared(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Acceleration1D{T}"/> from a value in StandardGravity.
 	/// </summary>
 	/// <param name="value">The value in StandardGravity.</param>
 	/// <returns>A new <see cref="Acceleration1D{T}"/> instance.</returns>
 	public static Acceleration1D<T> FromStandardGravity(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.StandardGravityToMeterPerSecondSquared)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Acceleration unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAccelerationUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="AccelerationMagnitude{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public AccelerationMagnitude<T> Magnitude() => AccelerationMagnitude<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Multiplies Acceleration1D by Duration to produce Velocity1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Velocity1D<T> operator *(Acceleration1D<T> left, Duration<T> right) => Multiply<Velocity1D<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity1D<T> operator *(Acceleration1D<T> left, Duration<T> right) => Multiply<Velocity1D<T>>(left, right);
+
+	/// <summary>
 	/// Divides Acceleration1D by Duration to produce Jerk1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Jerk1D<T> operator /(Acceleration1D<T> left, Duration<T> right) => Divide<Jerk1D<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk1D<T> operator /(Acceleration1D<T> left, Duration<T> right) => Divide<Jerk1D<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AccelerationMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AccelerationMagnitude.g.cs
index 12a8981e..7b656a16 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AccelerationMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AccelerationMagnitude.g.cs
@@ -25,40 +25,52 @@ public partial record AccelerationMagnitude<T> : PhysicalQuantity<AccelerationMa
 	/// <returns>A new <see cref="AccelerationMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AccelerationMagnitude<T> FromMeterPerSecondSquared(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="AccelerationMagnitude{T}"/> from a value in StandardGravity.
 	/// </summary>
 	/// <param name="value">The value in StandardGravity.</param>
 	/// <returns>A new <see cref="AccelerationMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AccelerationMagnitude<T> FromStandardGravity(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.StandardGravityToMeterPerSecondSquared)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Acceleration unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAccelerationUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two AccelerationMagnitude values, returning the absolute difference as a non-negative AccelerationMagnitude.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AccelerationMagnitude<T> operator -(AccelerationMagnitude<T> left, AccelerationMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator -(AccelerationMagnitude<T> left, AccelerationMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies AccelerationMagnitude by Mass to produce ForceMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ForceMagnitude<T> operator *(AccelerationMagnitude<T> left, Mass<T> right) => Multiply<ForceMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(AccelerationMagnitude<T> left, Mass<T> right) => Multiply<ForceMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies AccelerationMagnitude by Duration to produce Speed.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Speed<T> operator *(AccelerationMagnitude<T> left, Duration<T> right) => Multiply<Speed<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(AccelerationMagnitude<T> left, Duration<T> right) => Multiply<Speed<T>>(left, right);
+
+	/// <summary>
 	/// Divides AccelerationMagnitude by Duration to produce JerkMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static JerkMagnitude<T> operator /(AccelerationMagnitude<T> left, Duration<T> right) => Divide<JerkMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static JerkMagnitude<T> operator /(AccelerationMagnitude<T> left, Duration<T> right) => Divide<JerkMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides AccelerationMagnitude by JerkMagnitude to produce Duration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Duration<T> operator /(AccelerationMagnitude<T> left, JerkMagnitude<T> right) => Divide<Duration<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(AccelerationMagnitude<T> left, JerkMagnitude<T> right) => Divide<Duration<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AcousticImpedance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AcousticImpedance.g.cs
index a0729bc8..6d641f27 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AcousticImpedance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AcousticImpedance.g.cs
@@ -25,17 +25,20 @@ public partial record AcousticImpedance<T> : PhysicalQuantity<AcousticImpedance<
 	/// <returns>A new <see cref="AcousticImpedance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AcousticImpedance<T> FromPascalSecondPerMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AcousticImpedance unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAcousticImpedanceUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two AcousticImpedance values, returning the absolute difference as a non-negative AcousticImpedance.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AcousticImpedance<T> operator -(AcousticImpedance<T> left, AcousticImpedance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AcousticImpedance<T> operator -(AcousticImpedance<T> left, AcousticImpedance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ActivationEnergy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ActivationEnergy.g.cs
index 0b89d167..73f7b013 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ActivationEnergy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ActivationEnergy.g.cs
@@ -26,34 +26,42 @@ public partial record ActivationEnergy<T> : PhysicalQuantity<ActivationEnergy<T>
 	/// <returns>A new ActivationEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ActivationEnergy<T> FromJoulePerMole(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ActivationEnergy from a value in KilojoulePerMole.
 	/// </summary>
 	/// <param name="value">The value in KilojoulePerMole.</param>
 	/// <returns>A new ActivationEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ActivationEnergy<T> FromKilojoulePerMole(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilojoulePerMoleToJoulePerMole)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ActivationEnergy from a value in CaloriePerMole.
 	/// </summary>
 	/// <param name="value">The value in CaloriePerMole.</param>
 	/// <returns>A new ActivationEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ActivationEnergy<T> FromCaloriePerMole(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.CaloriePerMoleToJoulePerMole)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-MolarEnergy unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IMolarEnergyUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to MolarEnergy.</summary>
+
+	/// <summary>Implicit conversion to MolarEnergy.</summary>
 	public static implicit operator MolarEnergy<T>(ActivationEnergy<T> value) => MolarEnergy<T>.Create(value.Value);
-/// <summary>Explicit conversion from MolarEnergy.</summary>
+
+	/// <summary>Explicit conversion from MolarEnergy.</summary>
 	public static explicit operator ActivationEnergy<T>(MolarEnergy<T> value) => Create(value.Value);
-/// <summary>Creates a ActivationEnergy from a MolarEnergy value.</summary>
+
+	/// <summary>Creates a ActivationEnergy from a MolarEnergy value.</summary>
 	public static ActivationEnergy<T> From(MolarEnergy<T> value) => Create(value.Value);
-/// <summary>Subtracts two ActivationEnergy values, returning the absolute difference as a non-negative ActivationEnergy.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ActivationEnergy<T> operator -(ActivationEnergy<T> left, ActivationEnergy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two ActivationEnergy values, returning the absolute difference as a non-negative ActivationEnergy.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ActivationEnergy<T> operator -(ActivationEnergy<T> left, ActivationEnergy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Admittance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Admittance.g.cs
index e2ff6a1f..2a74d8db 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Admittance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Admittance.g.cs
@@ -26,20 +26,26 @@ public partial record Admittance<T> : PhysicalQuantity<Admittance<T>, T>, IVecto
 	/// <returns>A new Admittance instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Admittance<T> FromSiemens(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricConductance unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricConductanceUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Conductance.</summary>
+
+	/// <summary>Implicit conversion to Conductance.</summary>
 	public static implicit operator Conductance<T>(Admittance<T> value) => Conductance<T>.Create(value.Value);
-/// <summary>Explicit conversion from Conductance.</summary>
+
+	/// <summary>Explicit conversion from Conductance.</summary>
 	public static explicit operator Admittance<T>(Conductance<T> value) => Create(value.Value);
-/// <summary>Creates a Admittance from a Conductance value.</summary>
+
+	/// <summary>Creates a Admittance from a Conductance value.</summary>
 	public static Admittance<T> From(Conductance<T> value) => Create(value.Value);
-/// <summary>Subtracts two Admittance values, returning the absolute difference as a non-negative Admittance.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Admittance<T> operator -(Admittance<T> left, Admittance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Admittance values, returning the absolute difference as a non-negative Admittance.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Admittance<T> operator -(Admittance<T> left, Admittance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Airspeed.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Airspeed.g.cs
index cbf5f36e..f7bd8c5a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Airspeed.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Airspeed.g.cs
@@ -26,48 +26,58 @@ public partial record Airspeed<T> : PhysicalQuantity<Airspeed<T>, T>, IVector0<A
 	/// <returns>A new Airspeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Airspeed<T> FromMeterPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Airspeed from a value in KilometerPerHour.
 	/// </summary>
 	/// <param name="value">The value in KilometerPerHour.</param>
 	/// <returns>A new Airspeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Airspeed<T> FromKilometerPerHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilometerPerHourToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Airspeed from a value in MilePerHour.
 	/// </summary>
 	/// <param name="value">The value in MilePerHour.</param>
 	/// <returns>A new Airspeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Airspeed<T> FromMilePerHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MilePerHourToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Airspeed from a value in FootPerSecond.
 	/// </summary>
 	/// <param name="value">The value in FootPerSecond.</param>
 	/// <returns>A new Airspeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Airspeed<T> FromFootPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FootPerSecondToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Airspeed from a value in Knot.
 	/// </summary>
 	/// <param name="value">The value in Knot.</param>
 	/// <returns>A new Airspeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Airspeed<T> FromKnot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KnotToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Velocity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IVelocityUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Speed.</summary>
+
+	/// <summary>Implicit conversion to Speed.</summary>
 	public static implicit operator Speed<T>(Airspeed<T> value) => Speed<T>.Create(value.Value);
-/// <summary>Explicit conversion from Speed.</summary>
+
+	/// <summary>Explicit conversion from Speed.</summary>
 	public static explicit operator Airspeed<T>(Speed<T> value) => Create(value.Value);
-/// <summary>Creates a Airspeed from a Speed value.</summary>
+
+	/// <summary>Creates a Airspeed from a Speed value.</summary>
 	public static Airspeed<T> From(Speed<T> value) => Create(value.Value);
-/// <summary>Subtracts two Airspeed values, returning the absolute difference as a non-negative Airspeed.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Airspeed<T> operator -(Airspeed<T> left, Airspeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Airspeed values, returning the absolute difference as a non-negative Airspeed.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Airspeed<T> operator -(Airspeed<T> left, Airspeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Altitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Altitude.g.cs
index 4c1e10b8..5f516a0e 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Altitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Altitude.g.cs
@@ -26,97 +26,114 @@ public partial record Altitude<T> : PhysicalQuantity<Altitude<T>, T>, IVector0<A
 	/// <returns>A new Altitude instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Altitude<T> FromMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Altitude from a value in Kilometer.
 	/// </summary>
 	/// <param name="value">The value in Kilometer.</param>
 	/// <returns>A new Altitude instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Altitude<T> FromKilometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Altitude from a value in Centimeter.
 	/// </summary>
 	/// <param name="value">The value in Centimeter.</param>
 	/// <returns>A new Altitude instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Altitude<T> FromCentimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Centi)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Altitude from a value in Millimeter.
 	/// </summary>
 	/// <param name="value">The value in Millimeter.</param>
 	/// <returns>A new Altitude instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Altitude<T> FromMillimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Altitude from a value in Micrometer.
 	/// </summary>
 	/// <param name="value">The value in Micrometer.</param>
 	/// <returns>A new Altitude instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Altitude<T> FromMicrometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Altitude from a value in Nanometer.
 	/// </summary>
 	/// <param name="value">The value in Nanometer.</param>
 	/// <returns>A new Altitude instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Altitude<T> FromNanometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Altitude from a value in Angstrom.
 	/// </summary>
 	/// <param name="value">The value in Angstrom.</param>
 	/// <returns>A new Altitude instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Altitude<T> FromAngstrom(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AngstromToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Altitude from a value in Foot.
 	/// </summary>
 	/// <param name="value">The value in Foot.</param>
 	/// <returns>A new Altitude instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Altitude<T> FromFoot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FeetToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Altitude from a value in Inch.
 	/// </summary>
 	/// <param name="value">The value in Inch.</param>
 	/// <returns>A new Altitude instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Altitude<T> FromInch(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.InchesToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Altitude from a value in Yard.
 	/// </summary>
 	/// <param name="value">The value in Yard.</param>
 	/// <returns>A new Altitude instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Altitude<T> FromYard(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YardToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Altitude from a value in Mile.
 	/// </summary>
 	/// <param name="value">The value in Mile.</param>
 	/// <returns>A new Altitude instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Altitude<T> FromMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Altitude from a value in NauticalMile.
 	/// </summary>
 	/// <param name="value">The value in NauticalMile.</param>
 	/// <returns>A new Altitude instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Altitude<T> FromNauticalMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.NauticalMileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Length unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Length.</summary>
+
+	/// <summary>Implicit conversion to Length.</summary>
 	public static implicit operator Length<T>(Altitude<T> value) => Length<T>.Create(value.Value);
-/// <summary>Explicit conversion from Length.</summary>
+
+	/// <summary>Explicit conversion from Length.</summary>
 	public static explicit operator Altitude<T>(Length<T> value) => Create(value.Value);
-/// <summary>Creates a Altitude from a Length value.</summary>
+
+	/// <summary>Creates a Altitude from a Length value.</summary>
 	public static Altitude<T> From(Length<T> value) => Create(value.Value);
-/// <summary>Subtracts two Altitude values, returning the absolute difference as a non-negative Altitude.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Altitude<T> operator -(Altitude<T> left, Altitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Altitude values, returning the absolute difference as a non-negative Altitude.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Altitude<T> operator -(Altitude<T> left, Altitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AmountOfSubstance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AmountOfSubstance.g.cs
index 1150bff3..5e21ca1b 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AmountOfSubstance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AmountOfSubstance.g.cs
@@ -25,55 +25,72 @@ public partial record AmountOfSubstance<T> : PhysicalQuantity<AmountOfSubstance<
 	/// <returns>A new <see cref="AmountOfSubstance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AmountOfSubstance<T> FromMole(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="AmountOfSubstance{T}"/> from a value in Kilomole.
 	/// </summary>
 	/// <param name="value">The value in Kilomole.</param>
 	/// <returns>A new <see cref="AmountOfSubstance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AmountOfSubstance<T> FromKilomole(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="AmountOfSubstance{T}"/> from a value in Millimole.
 	/// </summary>
 	/// <param name="value">The value in Millimole.</param>
 	/// <returns>A new <see cref="AmountOfSubstance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AmountOfSubstance<T> FromMillimole(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AmountOfSubstance unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAmountOfSubstanceUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two AmountOfSubstance values, returning the absolute difference as a non-negative AmountOfSubstance.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AmountOfSubstance<T> operator -(AmountOfSubstance<T> left, AmountOfSubstance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator -(AmountOfSubstance<T> left, AmountOfSubstance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Divides AmountOfSubstance by Volume to produce Concentration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Concentration<T> operator /(AmountOfSubstance<T> left, Volume<T> right) => Divide<Concentration<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Concentration<T> operator /(AmountOfSubstance<T> left, Volume<T> right) => Divide<Concentration<T>>(left, right);
+
+	/// <summary>
 	/// Divides AmountOfSubstance by Concentration to produce Volume.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Volume<T> operator /(AmountOfSubstance<T> left, Concentration<T> right) => Divide<Volume<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator /(AmountOfSubstance<T> left, Concentration<T> right) => Divide<Volume<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies AmountOfSubstance by MolarMass to produce Mass.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Mass<T> operator *(AmountOfSubstance<T> left, MolarMass<T> right) => Multiply<Mass<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator *(AmountOfSubstance<T> left, MolarMass<T> right) => Multiply<Mass<T>>(left, right);
+
+	/// <summary>
 	/// Divides AmountOfSubstance by Duration to produce CatalyticActivity.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static CatalyticActivity<T> operator /(AmountOfSubstance<T> left, Duration<T> right) => Divide<CatalyticActivity<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static CatalyticActivity<T> operator /(AmountOfSubstance<T> left, Duration<T> right) => Divide<CatalyticActivity<T>>(left, right);
+
+	/// <summary>
 	/// Divides AmountOfSubstance by CatalyticActivity to produce Duration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Duration<T> operator /(AmountOfSubstance<T> left, CatalyticActivity<T> right) => Divide<Duration<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(AmountOfSubstance<T> left, CatalyticActivity<T> right) => Divide<Duration<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies AmountOfSubstance by MolarEnergy to produce Energy.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Energy<T> operator *(AmountOfSubstance<T> left, MolarEnergy<T> right) => Multiply<Energy<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(AmountOfSubstance<T> left, MolarEnergy<T> right) => Multiply<Energy<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Angle.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Angle.g.cs
index ba7a1358..f7ea0051 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Angle.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Angle.g.cs
@@ -25,57 +25,70 @@ public partial record Angle<T> : PhysicalQuantity<Angle<T>, T>, IVector0<Angle<T
 	/// <returns>A new <see cref="Angle{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Angle<T> FromRadian(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Angle{T}"/> from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new <see cref="Angle{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Angle<T> FromDegree(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Angle{T}"/> from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new <see cref="Angle{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Angle<T> FromGradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Angle{T}"/> from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new <see cref="Angle{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Angle<T> FromRevolution(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Angle{T}"/> from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new <see cref="Angle{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Angle<T> FromMilliradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AngularDisplacement unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAngularDisplacementUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Angle values, returning the absolute difference as a non-negative Angle.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Angle<T> operator -(Angle<T> left, Angle<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Angle<T> operator -(Angle<T> left, Angle<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Divides Angle by Duration to produce AngularSpeed.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularSpeed<T> operator /(Angle<T> left, Duration<T> right) => Divide<AngularSpeed<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularSpeed<T> operator /(Angle<T> left, Duration<T> right) => Divide<AngularSpeed<T>>(left, right);
+
+	/// <summary>
 	/// Divides Angle by AngularSpeed to produce Duration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Duration<T> operator /(Angle<T> left, AngularSpeed<T> right) => Divide<Duration<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Angle<T> left, AngularSpeed<T> right) => Divide<Duration<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Angle by TorqueMagnitude to produce Energy.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Energy<T> operator *(Angle<T> left, TorqueMagnitude<T> right) => Multiply<Energy<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Angle<T> left, TorqueMagnitude<T> right) => Multiply<Energy<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAcceleration1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAcceleration1D.g.cs
index 10e7ff4c..a8f1c20d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAcceleration1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAcceleration1D.g.cs
@@ -24,25 +24,31 @@ public partial record AngularAcceleration1D<T> : PhysicalQuantity<AngularAcceler
 	/// <param name="value">The value in RadianPerSecondSquared.</param>
 	/// <returns>A new <see cref="AngularAcceleration1D{T}"/> instance.</returns>
 	public static AngularAcceleration1D<T> FromRadianPerSecondSquared(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AngularAcceleration unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAngularAccelerationUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="AngularAccelerationMagnitude{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public AngularAccelerationMagnitude<T> Magnitude() => AngularAccelerationMagnitude<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Multiplies AngularAcceleration1D by Duration to produce AngularVelocity1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularVelocity1D<T> operator *(AngularAcceleration1D<T> left, Duration<T> right) => Multiply<AngularVelocity1D<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity1D<T> operator *(AngularAcceleration1D<T> left, Duration<T> right) => Multiply<AngularVelocity1D<T>>(left, right);
+
+	/// <summary>
 	/// Divides AngularAcceleration1D by Duration to produce AngularJerk1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularJerk1D<T> operator /(AngularAcceleration1D<T> left, Duration<T> right) => Divide<AngularJerk1D<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularJerk1D<T> operator /(AngularAcceleration1D<T> left, Duration<T> right) => Divide<AngularJerk1D<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAccelerationMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAccelerationMagnitude.g.cs
index dd017ca1..f1d8c566 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAccelerationMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAccelerationMagnitude.g.cs
@@ -25,33 +25,44 @@ public partial record AngularAccelerationMagnitude<T> : PhysicalQuantity<Angular
 	/// <returns>A new <see cref="AngularAccelerationMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AngularAccelerationMagnitude<T> FromRadianPerSecondSquared(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AngularAcceleration unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAngularAccelerationUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two AngularAccelerationMagnitude values, returning the absolute difference as a non-negative AngularAccelerationMagnitude.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularAccelerationMagnitude<T> operator -(AngularAccelerationMagnitude<T> left, AngularAccelerationMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAccelerationMagnitude<T> operator -(AngularAccelerationMagnitude<T> left, AngularAccelerationMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies AngularAccelerationMagnitude by Duration to produce AngularSpeed.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularSpeed<T> operator *(AngularAccelerationMagnitude<T> left, Duration<T> right) => Multiply<AngularSpeed<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularSpeed<T> operator *(AngularAccelerationMagnitude<T> left, Duration<T> right) => Multiply<AngularSpeed<T>>(left, right);
+
+	/// <summary>
 	/// Divides AngularAccelerationMagnitude by Duration to produce AngularJerkMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularJerkMagnitude<T> operator /(AngularAccelerationMagnitude<T> left, Duration<T> right) => Divide<AngularJerkMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularJerkMagnitude<T> operator /(AngularAccelerationMagnitude<T> left, Duration<T> right) => Divide<AngularJerkMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides AngularAccelerationMagnitude by AngularJerkMagnitude to produce Duration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Duration<T> operator /(AngularAccelerationMagnitude<T> left, AngularJerkMagnitude<T> right) => Divide<Duration<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(AngularAccelerationMagnitude<T> left, AngularJerkMagnitude<T> right) => Divide<Duration<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies AngularAccelerationMagnitude by MomentOfInertia to produce TorqueMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static TorqueMagnitude<T> operator *(AngularAccelerationMagnitude<T> left, MomentOfInertia<T> right) => Multiply<TorqueMagnitude<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static TorqueMagnitude<T> operator *(AngularAccelerationMagnitude<T> left, MomentOfInertia<T> right) => Multiply<TorqueMagnitude<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularJerk1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularJerk1D.g.cs
index 756d38af..f1ab6bd0 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularJerk1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularJerk1D.g.cs
@@ -24,21 +24,25 @@ public partial record AngularJerk1D<T> : PhysicalQuantity<AngularJerk1D<T>, T>,
 	/// <param name="value">The value in RadianPerSecondCubed.</param>
 	/// <returns>A new <see cref="AngularJerk1D{T}"/> instance.</returns>
 	public static AngularJerk1D<T> FromRadianPerSecondCubed(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AngularJerk unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAngularJerkUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="AngularJerkMagnitude{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public AngularJerkMagnitude<T> Magnitude() => AngularJerkMagnitude<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Multiplies AngularJerk1D by Duration to produce AngularAcceleration1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularAcceleration1D<T> operator *(AngularJerk1D<T> left, Duration<T> right) => Multiply<AngularAcceleration1D<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAcceleration1D<T> operator *(AngularJerk1D<T> left, Duration<T> right) => Multiply<AngularAcceleration1D<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularJerkMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularJerkMagnitude.g.cs
index 73ca866e..9916ad7c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularJerkMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularJerkMagnitude.g.cs
@@ -25,21 +25,26 @@ public partial record AngularJerkMagnitude<T> : PhysicalQuantity<AngularJerkMagn
 	/// <returns>A new <see cref="AngularJerkMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AngularJerkMagnitude<T> FromRadianPerSecondCubed(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AngularJerk unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAngularJerkUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two AngularJerkMagnitude values, returning the absolute difference as a non-negative AngularJerkMagnitude.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularJerkMagnitude<T> operator -(AngularJerkMagnitude<T> left, AngularJerkMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularJerkMagnitude<T> operator -(AngularJerkMagnitude<T> left, AngularJerkMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies AngularJerkMagnitude by Duration to produce AngularAccelerationMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularAccelerationMagnitude<T> operator *(AngularJerkMagnitude<T> left, Duration<T> right) => Multiply<AngularAccelerationMagnitude<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAccelerationMagnitude<T> operator *(AngularJerkMagnitude<T> left, Duration<T> right) => Multiply<AngularAccelerationMagnitude<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentum1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentum1D.g.cs
index e9125239..d4383ff5 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentum1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentum1D.g.cs
@@ -24,21 +24,25 @@ public partial record AngularMomentum1D<T> : PhysicalQuantity<AngularMomentum1D<
 	/// <param name="value">The value in KilogramMeterSquaredPerSecond.</param>
 	/// <returns>A new <see cref="AngularMomentum1D{T}"/> instance.</returns>
 	public static AngularMomentum1D<T> FromKilogramMeterSquaredPerSecond(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AngularMomentum unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAngularMomentumUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="AngularMomentumMagnitude{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public AngularMomentumMagnitude<T> Magnitude() => AngularMomentumMagnitude<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Divides AngularMomentum1D by Duration to produce Torque1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Torque1D<T> operator /(AngularMomentum1D<T> left, Duration<T> right) => Divide<Torque1D<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Torque1D<T> operator /(AngularMomentum1D<T> left, Duration<T> right) => Divide<Torque1D<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentumMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentumMagnitude.g.cs
index bcebbba9..9fa26ecb 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentumMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentumMagnitude.g.cs
@@ -25,29 +25,38 @@ public partial record AngularMomentumMagnitude<T> : PhysicalQuantity<AngularMome
 	/// <returns>A new <see cref="AngularMomentumMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AngularMomentumMagnitude<T> FromKilogramMeterSquaredPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AngularMomentum unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAngularMomentumUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two AngularMomentumMagnitude values, returning the absolute difference as a non-negative AngularMomentumMagnitude.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularMomentumMagnitude<T> operator -(AngularMomentumMagnitude<T> left, AngularMomentumMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentumMagnitude<T> operator -(AngularMomentumMagnitude<T> left, AngularMomentumMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Divides AngularMomentumMagnitude by Duration to produce TorqueMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static TorqueMagnitude<T> operator /(AngularMomentumMagnitude<T> left, Duration<T> right) => Divide<TorqueMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static TorqueMagnitude<T> operator /(AngularMomentumMagnitude<T> left, Duration<T> right) => Divide<TorqueMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides AngularMomentumMagnitude by AngularSpeed to produce MomentOfInertia.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MomentOfInertia<T> operator /(AngularMomentumMagnitude<T> left, AngularSpeed<T> right) => Divide<MomentOfInertia<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentOfInertia<T> operator /(AngularMomentumMagnitude<T> left, AngularSpeed<T> right) => Divide<MomentOfInertia<T>>(left, right);
+
+	/// <summary>
 	/// Divides AngularMomentumMagnitude by MomentOfInertia to produce AngularSpeed.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularSpeed<T> operator /(AngularMomentumMagnitude<T> left, MomentOfInertia<T> right) => Divide<AngularSpeed<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularSpeed<T> operator /(AngularMomentumMagnitude<T> left, MomentOfInertia<T> right) => Divide<AngularSpeed<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularSpeed.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularSpeed.g.cs
index eb2c4ba3..f139761a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularSpeed.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularSpeed.g.cs
@@ -25,40 +25,52 @@ public partial record AngularSpeed<T> : PhysicalQuantity<AngularSpeed<T>, T>, IV
 	/// <returns>A new <see cref="AngularSpeed{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AngularSpeed<T> FromRadianPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="AngularSpeed{T}"/> from a value in RevolutionPerMinute.
 	/// </summary>
 	/// <param name="value">The value in RevolutionPerMinute.</param>
 	/// <returns>A new <see cref="AngularSpeed{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AngularSpeed<T> FromRevolutionPerMinute(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.RevolutionPerMinuteToRadianPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AngularVelocity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAngularVelocityUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two AngularSpeed values, returning the absolute difference as a non-negative AngularSpeed.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularSpeed<T> operator -(AngularSpeed<T> left, AngularSpeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularSpeed<T> operator -(AngularSpeed<T> left, AngularSpeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies AngularSpeed by Duration to produce Angle.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Angle<T> operator *(AngularSpeed<T> left, Duration<T> right) => Multiply<Angle<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Angle<T> operator *(AngularSpeed<T> left, Duration<T> right) => Multiply<Angle<T>>(left, right);
+
+	/// <summary>
 	/// Divides AngularSpeed by Duration to produce AngularAccelerationMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularAccelerationMagnitude<T> operator /(AngularSpeed<T> left, Duration<T> right) => Divide<AngularAccelerationMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAccelerationMagnitude<T> operator /(AngularSpeed<T> left, Duration<T> right) => Divide<AngularAccelerationMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides AngularSpeed by AngularAccelerationMagnitude to produce Duration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Duration<T> operator /(AngularSpeed<T> left, AngularAccelerationMagnitude<T> right) => Divide<Duration<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(AngularSpeed<T> left, AngularAccelerationMagnitude<T> right) => Divide<Duration<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies AngularSpeed by MomentOfInertia to produce AngularMomentumMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularMomentumMagnitude<T> operator *(AngularSpeed<T> left, MomentOfInertia<T> right) => Multiply<AngularMomentumMagnitude<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentumMagnitude<T> operator *(AngularSpeed<T> left, MomentOfInertia<T> right) => Multiply<AngularMomentumMagnitude<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularVelocity1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularVelocity1D.g.cs
index 85c2a771..97295664 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularVelocity1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularVelocity1D.g.cs
@@ -24,31 +24,38 @@ public partial record AngularVelocity1D<T> : PhysicalQuantity<AngularVelocity1D<
 	/// <param name="value">The value in RadianPerSecond.</param>
 	/// <returns>A new <see cref="AngularVelocity1D{T}"/> instance.</returns>
 	public static AngularVelocity1D<T> FromRadianPerSecond(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="AngularVelocity1D{T}"/> from a value in RevolutionPerMinute.
 	/// </summary>
 	/// <param name="value">The value in RevolutionPerMinute.</param>
 	/// <returns>A new <see cref="AngularVelocity1D{T}"/> instance.</returns>
 	public static AngularVelocity1D<T> FromRevolutionPerMinute(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.RevolutionPerMinuteToRadianPerSecond)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AngularVelocity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAngularVelocityUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="AngularSpeed{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public AngularSpeed<T> Magnitude() => AngularSpeed<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Multiplies AngularVelocity1D by Duration to produce SignedAngle.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SignedAngle<T> operator *(AngularVelocity1D<T> left, Duration<T> right) => Multiply<SignedAngle<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedAngle<T> operator *(AngularVelocity1D<T> left, Duration<T> right) => Multiply<SignedAngle<T>>(left, right);
+
+	/// <summary>
 	/// Divides AngularVelocity1D by Duration to produce AngularAcceleration1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularAcceleration1D<T> operator /(AngularVelocity1D<T> left, Duration<T> right) => Divide<AngularAcceleration1D<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAcceleration1D<T> operator /(AngularVelocity1D<T> left, Duration<T> right) => Divide<AngularAcceleration1D<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ApertureAngle.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ApertureAngle.g.cs
index b6b9f159..7f065b70 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ApertureAngle.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ApertureAngle.g.cs
@@ -26,48 +26,58 @@ public partial record ApertureAngle<T> : PhysicalQuantity<ApertureAngle<T>, T>,
 	/// <returns>A new ApertureAngle instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ApertureAngle<T> FromRadian(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ApertureAngle from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new ApertureAngle instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ApertureAngle<T> FromDegree(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ApertureAngle from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new ApertureAngle instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ApertureAngle<T> FromGradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ApertureAngle from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new ApertureAngle instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ApertureAngle<T> FromRevolution(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ApertureAngle from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new ApertureAngle instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ApertureAngle<T> FromMilliradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AngularDisplacement unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAngularDisplacementUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Angle.</summary>
+
+	/// <summary>Implicit conversion to Angle.</summary>
 	public static implicit operator Angle<T>(ApertureAngle<T> value) => Angle<T>.Create(value.Value);
-/// <summary>Explicit conversion from Angle.</summary>
+
+	/// <summary>Explicit conversion from Angle.</summary>
 	public static explicit operator ApertureAngle<T>(Angle<T> value) => Create(value.Value);
-/// <summary>Creates a ApertureAngle from a Angle value.</summary>
+
+	/// <summary>Creates a ApertureAngle from a Angle value.</summary>
 	public static ApertureAngle<T> From(Angle<T> value) => Create(value.Value);
-/// <summary>Subtracts two ApertureAngle values, returning the absolute difference as a non-negative ApertureAngle.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ApertureAngle<T> operator -(ApertureAngle<T> left, ApertureAngle<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two ApertureAngle values, returning the absolute difference as a non-negative ApertureAngle.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ApertureAngle<T> operator -(ApertureAngle<T> left, ApertureAngle<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Area.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Area.g.cs
index 94530571..372f9db0 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Area.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Area.g.cs
@@ -25,98 +25,124 @@ public partial record Area<T> : PhysicalQuantity<Area<T>, T>, IVector0<Area<T>,
 	/// <returns>A new <see cref="Area{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Area<T> FromSquareMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Area{T}"/> from a value in SquareKilometer.
 	/// </summary>
 	/// <param name="value">The value in SquareKilometer.</param>
 	/// <returns>A new <see cref="Area{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Area<T> FromSquareKilometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.SquareKilometerToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Area{T}"/> from a value in SquareCentimeter.
 	/// </summary>
 	/// <param name="value">The value in SquareCentimeter.</param>
 	/// <returns>A new <see cref="Area{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Area<T> FromSquareCentimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.SquareCentimeterToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Area{T}"/> from a value in SquareFoot.
 	/// </summary>
 	/// <param name="value">The value in SquareFoot.</param>
 	/// <returns>A new <see cref="Area{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Area<T> FromSquareFoot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.SquareFootToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Area{T}"/> from a value in SquareInch.
 	/// </summary>
 	/// <param name="value">The value in SquareInch.</param>
 	/// <returns>A new <see cref="Area{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Area<T> FromSquareInch(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.SquareInchToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Area{T}"/> from a value in SquareMile.
 	/// </summary>
 	/// <param name="value">The value in SquareMile.</param>
 	/// <returns>A new <see cref="Area{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Area<T> FromSquareMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.SquareMileToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Area{T}"/> from a value in Hectare.
 	/// </summary>
 	/// <param name="value">The value in Hectare.</param>
 	/// <returns>A new <see cref="Area{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Area<T> FromHectare(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.HectareToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Area{T}"/> from a value in Acre.
 	/// </summary>
 	/// <param name="value">The value in Acre.</param>
 	/// <returns>A new <see cref="Area{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Area<T> FromAcre(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AcreToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Area unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAreaUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Area values, returning the absolute difference as a non-negative Area.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Area<T> operator -(Area<T> left, Area<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator -(Area<T> left, Area<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Divides Area by Length to produce Length.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Length<T> operator /(Area<T> left, Length<T> right) => Divide<Length<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(Area<T> left, Length<T> right) => Divide<Length<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Area by Length to produce Volume.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Volume<T> operator *(Area<T> left, Length<T> right) => Multiply<Volume<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(Area<T> left, Length<T> right) => Multiply<Volume<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Area by Pressure to produce ForceMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ForceMagnitude<T> operator *(Area<T> left, Pressure<T> right) => Multiply<ForceMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(Area<T> left, Pressure<T> right) => Multiply<ForceMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Area by ElectricFieldMagnitude to produce ElectricFlux.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ElectricFlux<T> operator *(Area<T> left, ElectricFieldMagnitude<T> right) => Multiply<ElectricFlux<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ElectricFlux<T> operator *(Area<T> left, ElectricFieldMagnitude<T> right) => Multiply<ElectricFlux<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Area by Illuminance to produce LuminousFlux.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static LuminousFlux<T> operator *(Area<T> left, Illuminance<T> right) => Multiply<LuminousFlux<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static LuminousFlux<T> operator *(Area<T> left, Illuminance<T> right) => Multiply<LuminousFlux<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Area by MagneticFluxDensityMagnitude to produce MagneticFlux.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MagneticFlux<T> operator *(Area<T> left, MagneticFluxDensityMagnitude<T> right) => Multiply<MagneticFlux<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFlux<T> operator *(Area<T> left, MagneticFluxDensityMagnitude<T> right) => Multiply<MagneticFlux<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Area by Irradiance to produce Power.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Power<T> operator *(Area<T> left, Irradiance<T> right) => Multiply<Power<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(Area<T> left, Irradiance<T> right) => Multiply<Power<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Area by Luminance to produce LuminousIntensity.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static LuminousIntensity<T> operator *(Area<T> left, Luminance<T> right) => Multiply<LuminousIntensity<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static LuminousIntensity<T> operator *(Area<T> left, Luminance<T> right) => Multiply<LuminousIntensity<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AtmosphericPressure.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AtmosphericPressure.g.cs
index 46d50711..415f2923 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AtmosphericPressure.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AtmosphericPressure.g.cs
@@ -26,55 +26,66 @@ public partial record AtmosphericPressure<T> : PhysicalQuantity<AtmosphericPress
 	/// <returns>A new AtmosphericPressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AtmosphericPressure<T> FromPascal(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new AtmosphericPressure from a value in Kilopascal.
 	/// </summary>
 	/// <param name="value">The value in Kilopascal.</param>
 	/// <returns>A new AtmosphericPressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AtmosphericPressure<T> FromKilopascal(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new AtmosphericPressure from a value in Bar.
 	/// </summary>
 	/// <param name="value">The value in Bar.</param>
 	/// <returns>A new AtmosphericPressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AtmosphericPressure<T> FromBar(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.BarToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new AtmosphericPressure from a value in Atmosphere.
 	/// </summary>
 	/// <param name="value">The value in Atmosphere.</param>
 	/// <returns>A new AtmosphericPressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AtmosphericPressure<T> FromAtmosphere(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AtmosphereToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new AtmosphericPressure from a value in Psi.
 	/// </summary>
 	/// <param name="value">The value in Psi.</param>
 	/// <returns>A new AtmosphericPressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AtmosphericPressure<T> FromPsi(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PsiToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new AtmosphericPressure from a value in Torr.
 	/// </summary>
 	/// <param name="value">The value in Torr.</param>
 	/// <returns>A new AtmosphericPressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AtmosphericPressure<T> FromTorr(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.TorrToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Pressure unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IPressureUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Pressure.</summary>
+
+	/// <summary>Implicit conversion to Pressure.</summary>
 	public static implicit operator Pressure<T>(AtmosphericPressure<T> value) => Pressure<T>.Create(value.Value);
-/// <summary>Explicit conversion from Pressure.</summary>
+
+	/// <summary>Explicit conversion from Pressure.</summary>
 	public static explicit operator AtmosphericPressure<T>(Pressure<T> value) => Create(value.Value);
-/// <summary>Creates a AtmosphericPressure from a Pressure value.</summary>
+
+	/// <summary>Creates a AtmosphericPressure from a Pressure value.</summary>
 	public static AtmosphericPressure<T> From(Pressure<T> value) => Create(value.Value);
-/// <summary>Subtracts two AtmosphericPressure values, returning the absolute difference as a non-negative AtmosphericPressure.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AtmosphericPressure<T> operator -(AtmosphericPressure<T> left, AtmosphericPressure<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two AtmosphericPressure values, returning the absolute difference as a non-negative AtmosphericPressure.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AtmosphericPressure<T> operator -(AtmosphericPressure<T> left, AtmosphericPressure<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AtomicMass.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AtomicMass.g.cs
index 4b75e4a8..41f56c9f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AtomicMass.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AtomicMass.g.cs
@@ -26,69 +26,82 @@ public partial record AtomicMass<T> : PhysicalQuantity<AtomicMass<T>, T>, IVecto
 	/// <returns>A new AtomicMass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AtomicMass<T> FromKilogram(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new AtomicMass from a value in Gram.
 	/// </summary>
 	/// <param name="value">The value in Gram.</param>
 	/// <returns>A new AtomicMass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AtomicMass<T> FromGram(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new AtomicMass from a value in Ton.
 	/// </summary>
 	/// <param name="value">The value in Ton.</param>
 	/// <returns>A new AtomicMass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AtomicMass<T> FromTon(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.TonToKilograms)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new AtomicMass from a value in Pound.
 	/// </summary>
 	/// <param name="value">The value in Pound.</param>
 	/// <returns>A new AtomicMass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AtomicMass<T> FromPound(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PoundToKilograms)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new AtomicMass from a value in Ounce.
 	/// </summary>
 	/// <param name="value">The value in Ounce.</param>
 	/// <returns>A new AtomicMass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AtomicMass<T> FromOunce(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.OunceToKilograms)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new AtomicMass from a value in Stone.
 	/// </summary>
 	/// <param name="value">The value in Stone.</param>
 	/// <returns>A new AtomicMass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AtomicMass<T> FromStone(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.StoneToKilograms)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new AtomicMass from a value in ShortTon.
 	/// </summary>
 	/// <param name="value">The value in ShortTon.</param>
 	/// <returns>A new AtomicMass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AtomicMass<T> FromShortTon(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.ShortTonToKilograms)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new AtomicMass from a value in AtomicMassUnit.
 	/// </summary>
 	/// <param name="value">The value in AtomicMassUnit.</param>
 	/// <returns>A new AtomicMass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static AtomicMass<T> FromAtomicMassUnit(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AtomicMassUnitToKilograms)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Mass unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IMassUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Mass.</summary>
+
+	/// <summary>Implicit conversion to Mass.</summary>
 	public static implicit operator Mass<T>(AtomicMass<T> value) => Mass<T>.Create(value.Value);
-/// <summary>Explicit conversion from Mass.</summary>
+
+	/// <summary>Explicit conversion from Mass.</summary>
 	public static explicit operator AtomicMass<T>(Mass<T> value) => Create(value.Value);
-/// <summary>Creates a AtomicMass from a Mass value.</summary>
+
+	/// <summary>Creates a AtomicMass from a Mass value.</summary>
 	public static AtomicMass<T> From(Mass<T> value) => Create(value.Value);
-/// <summary>Subtracts two AtomicMass values, returning the absolute difference as a non-negative AtomicMass.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AtomicMass<T> operator -(AtomicMass<T> left, AtomicMass<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two AtomicMass values, returning the absolute difference as a non-negative AtomicMass.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AtomicMass<T> operator -(AtomicMass<T> left, AtomicMass<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Bandwidth.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Bandwidth.g.cs
index 29032d67..7d9e1b95 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Bandwidth.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Bandwidth.g.cs
@@ -26,34 +26,42 @@ public partial record Bandwidth<T> : PhysicalQuantity<Bandwidth<T>, T>, IVector0
 	/// <returns>A new Bandwidth instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Bandwidth<T> FromHertz(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Bandwidth from a value in Kilohertz.
 	/// </summary>
 	/// <param name="value">The value in Kilohertz.</param>
 	/// <returns>A new Bandwidth instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Bandwidth<T> FromKilohertz(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Bandwidth from a value in Megahertz.
 	/// </summary>
 	/// <param name="value">The value in Megahertz.</param>
 	/// <returns>A new Bandwidth instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Bandwidth<T> FromMegahertz(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Mega)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Frequency unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IFrequencyUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Frequency.</summary>
+
+	/// <summary>Implicit conversion to Frequency.</summary>
 	public static implicit operator Frequency<T>(Bandwidth<T> value) => Frequency<T>.Create(value.Value);
-/// <summary>Explicit conversion from Frequency.</summary>
+
+	/// <summary>Explicit conversion from Frequency.</summary>
 	public static explicit operator Bandwidth<T>(Frequency<T> value) => Create(value.Value);
-/// <summary>Creates a Bandwidth from a Frequency value.</summary>
+
+	/// <summary>Creates a Bandwidth from a Frequency value.</summary>
 	public static Bandwidth<T> From(Frequency<T> value) => Create(value.Value);
-/// <summary>Subtracts two Bandwidth values, returning the absolute difference as a non-negative Bandwidth.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Bandwidth<T> operator -(Bandwidth<T> left, Bandwidth<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Bandwidth values, returning the absolute difference as a non-negative Bandwidth.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Bandwidth<T> operator -(Bandwidth<T> left, Bandwidth<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Bearing.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Bearing.g.cs
index 78db81a3..12aa0ce9 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Bearing.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Bearing.g.cs
@@ -25,42 +25,50 @@ public partial record Bearing<T> : PhysicalQuantity<Bearing<T>, T>, IVector1<Bea
 	/// <param name="value">The value in Radian.</param>
 	/// <returns>A new Bearing instance.</returns>
 	public static Bearing<T> FromRadian(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Bearing from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new Bearing instance.</returns>
 	public static Bearing<T> FromDegree(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Bearing from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new Bearing instance.</returns>
 	public static Bearing<T> FromGradian(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Bearing from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new Bearing instance.</returns>
 	public static Bearing<T> FromRevolution(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Bearing from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new Bearing instance.</returns>
 	public static Bearing<T> FromMilliradian(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Milli)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AngularDisplacement unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAngularDisplacementUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to SignedAngle.</summary>
+
+	/// <summary>Implicit conversion to SignedAngle.</summary>
 	public static implicit operator SignedAngle<T>(Bearing<T> value) => SignedAngle<T>.Create(value.Value);
-/// <summary>Explicit conversion from SignedAngle.</summary>
+
+	/// <summary>Explicit conversion from SignedAngle.</summary>
 	public static explicit operator Bearing<T>(SignedAngle<T> value) => Create(value.Value);
-/// <summary>Creates a Bearing from a SignedAngle value.</summary>
+
+	/// <summary>Creates a Bearing from a SignedAngle value.</summary>
 	public static Bearing<T> From(SignedAngle<T> value) => Create(value.Value);
-};
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/BulkModulus.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/BulkModulus.g.cs
index ac83f223..9dc8932f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/BulkModulus.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/BulkModulus.g.cs
@@ -26,55 +26,66 @@ public partial record BulkModulus<T> : PhysicalQuantity<BulkModulus<T>, T>, IVec
 	/// <returns>A new BulkModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static BulkModulus<T> FromPascal(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new BulkModulus from a value in Kilopascal.
 	/// </summary>
 	/// <param name="value">The value in Kilopascal.</param>
 	/// <returns>A new BulkModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static BulkModulus<T> FromKilopascal(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new BulkModulus from a value in Bar.
 	/// </summary>
 	/// <param name="value">The value in Bar.</param>
 	/// <returns>A new BulkModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static BulkModulus<T> FromBar(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.BarToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new BulkModulus from a value in Atmosphere.
 	/// </summary>
 	/// <param name="value">The value in Atmosphere.</param>
 	/// <returns>A new BulkModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static BulkModulus<T> FromAtmosphere(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AtmosphereToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new BulkModulus from a value in Psi.
 	/// </summary>
 	/// <param name="value">The value in Psi.</param>
 	/// <returns>A new BulkModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static BulkModulus<T> FromPsi(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PsiToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new BulkModulus from a value in Torr.
 	/// </summary>
 	/// <param name="value">The value in Torr.</param>
 	/// <returns>A new BulkModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static BulkModulus<T> FromTorr(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.TorrToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Pressure unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IPressureUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Pressure.</summary>
+
+	/// <summary>Implicit conversion to Pressure.</summary>
 	public static implicit operator Pressure<T>(BulkModulus<T> value) => Pressure<T>.Create(value.Value);
-/// <summary>Explicit conversion from Pressure.</summary>
+
+	/// <summary>Explicit conversion from Pressure.</summary>
 	public static explicit operator BulkModulus<T>(Pressure<T> value) => Create(value.Value);
-/// <summary>Creates a BulkModulus from a Pressure value.</summary>
+
+	/// <summary>Creates a BulkModulus from a Pressure value.</summary>
 	public static BulkModulus<T> From(Pressure<T> value) => Create(value.Value);
-/// <summary>Subtracts two BulkModulus values, returning the absolute difference as a non-negative BulkModulus.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static BulkModulus<T> operator -(BulkModulus<T> left, BulkModulus<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two BulkModulus values, returning the absolute difference as a non-negative BulkModulus.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static BulkModulus<T> operator -(BulkModulus<T> left, BulkModulus<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Capacitance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Capacitance.g.cs
index e03c3330..eccab1d8 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Capacitance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Capacitance.g.cs
@@ -25,42 +25,50 @@ public partial record Capacitance<T> : PhysicalQuantity<Capacitance<T>, T>, IVec
 	/// <returns>A new <see cref="Capacitance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Capacitance<T> FromFarad(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Capacitance{T}"/> from a value in Microfarad.
 	/// </summary>
 	/// <param name="value">The value in Microfarad.</param>
 	/// <returns>A new <see cref="Capacitance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Capacitance<T> FromMicrofarad(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Capacitance{T}"/> from a value in Nanofarad.
 	/// </summary>
 	/// <param name="value">The value in Nanofarad.</param>
 	/// <returns>A new <see cref="Capacitance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Capacitance<T> FromNanofarad(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Capacitance{T}"/> from a value in Picofarad.
 	/// </summary>
 	/// <param name="value">The value in Picofarad.</param>
 	/// <returns>A new <see cref="Capacitance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Capacitance<T> FromPicofarad(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Pico)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricCapacitance unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricCapacitanceUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Capacitance values, returning the absolute difference as a non-negative Capacitance.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Capacitance<T> operator -(Capacitance<T> left, Capacitance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Capacitance<T> operator -(Capacitance<T> left, Capacitance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Capacitance by VoltageMagnitude to produce ChargeMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ChargeMagnitude<T> operator *(Capacitance<T> left, VoltageMagnitude<T> right) => Multiply<ChargeMagnitude<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ChargeMagnitude<T> operator *(Capacitance<T> left, VoltageMagnitude<T> right) => Multiply<ChargeMagnitude<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Capacity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Capacity.g.cs
index 993d85df..22186762 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Capacity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Capacity.g.cs
@@ -26,90 +26,106 @@ public partial record Capacity<T> : PhysicalQuantity<Capacity<T>, T>, IVector0<C
 	/// <returns>A new Capacity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Capacity<T> FromCubicMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Capacity from a value in Liter.
 	/// </summary>
 	/// <param name="value">The value in Liter.</param>
 	/// <returns>A new Capacity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Capacity<T> FromLiter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.LiterToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Capacity from a value in Milliliter.
 	/// </summary>
 	/// <param name="value">The value in Milliliter.</param>
 	/// <returns>A new Capacity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Capacity<T> FromMilliliter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Capacity from a value in CubicCentimeter.
 	/// </summary>
 	/// <param name="value">The value in CubicCentimeter.</param>
 	/// <returns>A new Capacity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Capacity<T> FromCubicCentimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.CubicCentimeterToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Capacity from a value in CubicFoot.
 	/// </summary>
 	/// <param name="value">The value in CubicFoot.</param>
 	/// <returns>A new Capacity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Capacity<T> FromCubicFoot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.CubicFootToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Capacity from a value in CubicInch.
 	/// </summary>
 	/// <param name="value">The value in CubicInch.</param>
 	/// <returns>A new Capacity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Capacity<T> FromCubicInch(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.CubicInchToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Capacity from a value in Gallon.
 	/// </summary>
 	/// <param name="value">The value in Gallon.</param>
 	/// <returns>A new Capacity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Capacity<T> FromGallon(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GallonToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Capacity from a value in ImperialGallon.
 	/// </summary>
 	/// <param name="value">The value in ImperialGallon.</param>
 	/// <returns>A new Capacity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Capacity<T> FromImperialGallon(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.ImperialGallonToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Capacity from a value in USQuart.
 	/// </summary>
 	/// <param name="value">The value in USQuart.</param>
 	/// <returns>A new Capacity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Capacity<T> FromUSQuart(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.USQuartToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Capacity from a value in USPint.
 	/// </summary>
 	/// <param name="value">The value in USPint.</param>
 	/// <returns>A new Capacity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Capacity<T> FromUSPint(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.USPintToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Capacity from a value in USFluidOunce.
 	/// </summary>
 	/// <param name="value">The value in USFluidOunce.</param>
 	/// <returns>A new Capacity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Capacity<T> FromUSFluidOunce(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.USFluidOunceToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Volume unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IVolumeUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Volume.</summary>
+
+	/// <summary>Implicit conversion to Volume.</summary>
 	public static implicit operator Volume<T>(Capacity<T> value) => Volume<T>.Create(value.Value);
-/// <summary>Explicit conversion from Volume.</summary>
+
+	/// <summary>Explicit conversion from Volume.</summary>
 	public static explicit operator Capacity<T>(Volume<T> value) => Create(value.Value);
-/// <summary>Creates a Capacity from a Volume value.</summary>
+
+	/// <summary>Creates a Capacity from a Volume value.</summary>
 	public static Capacity<T> From(Volume<T> value) => Create(value.Value);
-/// <summary>Subtracts two Capacity values, returning the absolute difference as a non-negative Capacity.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Capacity<T> operator -(Capacity<T> left, Capacity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Capacity values, returning the absolute difference as a non-negative Capacity.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Capacity<T> operator -(Capacity<T> left, Capacity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CatalyticActivity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CatalyticActivity.g.cs
index afe12918..d6252376 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CatalyticActivity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CatalyticActivity.g.cs
@@ -25,28 +25,34 @@ public partial record CatalyticActivity<T> : PhysicalQuantity<CatalyticActivity<
 	/// <returns>A new <see cref="CatalyticActivity{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static CatalyticActivity<T> FromKatal(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="CatalyticActivity{T}"/> from a value in EnzymeUnit.
 	/// </summary>
 	/// <param name="value">The value in EnzymeUnit.</param>
 	/// <returns>A new <see cref="CatalyticActivity{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static CatalyticActivity<T> FromEnzymeUnit(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.EnzymeUnitToKatals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-CatalyticActivity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ICatalyticActivityUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two CatalyticActivity values, returning the absolute difference as a non-negative CatalyticActivity.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static CatalyticActivity<T> operator -(CatalyticActivity<T> left, CatalyticActivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static CatalyticActivity<T> operator -(CatalyticActivity<T> left, CatalyticActivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies CatalyticActivity by Duration to produce AmountOfSubstance.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AmountOfSubstance<T> operator *(CatalyticActivity<T> left, Duration<T> right) => Multiply<AmountOfSubstance<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator *(CatalyticActivity<T> left, Duration<T> right) => Multiply<AmountOfSubstance<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Charge.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Charge.g.cs
index 4035a24c..de8cb2cb 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Charge.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Charge.g.cs
@@ -24,27 +24,32 @@ public partial record Charge<T> : PhysicalQuantity<Charge<T>, T>, IVector1<Charg
 	/// <param name="value">The value in Coulomb.</param>
 	/// <returns>A new <see cref="Charge{T}"/> instance.</returns>
 	public static Charge<T> FromCoulomb(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Charge{T}"/> from a value in AmpereHour.
 	/// </summary>
 	/// <param name="value">The value in AmpereHour.</param>
 	/// <returns>A new <see cref="Charge{T}"/> instance.</returns>
 	public static Charge<T> FromAmpereHour(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.AmpereHourToCoulombs)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricCharge unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricChargeUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="ChargeMagnitude{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public ChargeMagnitude<T> Magnitude() => ChargeMagnitude<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Divides Charge by Duration to produce Current1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Current1D<T> operator /(Charge<T> left, Duration<T> right) => Divide<Current1D<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Current1D<T> operator /(Charge<T> left, Duration<T> right) => Divide<Current1D<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ChargeMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ChargeMagnitude.g.cs
index b620ac73..c761924d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ChargeMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ChargeMagnitude.g.cs
@@ -25,40 +25,52 @@ public partial record ChargeMagnitude<T> : PhysicalQuantity<ChargeMagnitude<T>,
 	/// <returns>A new <see cref="ChargeMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ChargeMagnitude<T> FromCoulomb(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="ChargeMagnitude{T}"/> from a value in AmpereHour.
 	/// </summary>
 	/// <param name="value">The value in AmpereHour.</param>
 	/// <returns>A new <see cref="ChargeMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ChargeMagnitude<T> FromAmpereHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AmpereHourToCoulombs)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricCharge unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricChargeUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two ChargeMagnitude values, returning the absolute difference as a non-negative ChargeMagnitude.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ChargeMagnitude<T> operator -(ChargeMagnitude<T> left, ChargeMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ChargeMagnitude<T> operator -(ChargeMagnitude<T> left, ChargeMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Divides ChargeMagnitude by Duration to produce CurrentMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static CurrentMagnitude<T> operator /(ChargeMagnitude<T> left, Duration<T> right) => Divide<CurrentMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static CurrentMagnitude<T> operator /(ChargeMagnitude<T> left, Duration<T> right) => Divide<CurrentMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides ChargeMagnitude by CurrentMagnitude to produce Duration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Duration<T> operator /(ChargeMagnitude<T> left, CurrentMagnitude<T> right) => Divide<Duration<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(ChargeMagnitude<T> left, CurrentMagnitude<T> right) => Divide<Duration<T>>(left, right);
+
+	/// <summary>
 	/// Divides ChargeMagnitude by VoltageMagnitude to produce Capacitance.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Capacitance<T> operator /(ChargeMagnitude<T> left, VoltageMagnitude<T> right) => Divide<Capacitance<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Capacitance<T> operator /(ChargeMagnitude<T> left, VoltageMagnitude<T> right) => Divide<Capacitance<T>>(left, right);
+
+	/// <summary>
 	/// Divides ChargeMagnitude by Capacitance to produce VoltageMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static VoltageMagnitude<T> operator /(ChargeMagnitude<T> left, Capacitance<T> right) => Divide<VoltageMagnitude<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator /(ChargeMagnitude<T> left, Capacitance<T> right) => Divide<VoltageMagnitude<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ClockSpeed.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ClockSpeed.g.cs
index 998a80d7..e803e1cf 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ClockSpeed.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ClockSpeed.g.cs
@@ -26,34 +26,42 @@ public partial record ClockSpeed<T> : PhysicalQuantity<ClockSpeed<T>, T>, IVecto
 	/// <returns>A new ClockSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ClockSpeed<T> FromHertz(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ClockSpeed from a value in Kilohertz.
 	/// </summary>
 	/// <param name="value">The value in Kilohertz.</param>
 	/// <returns>A new ClockSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ClockSpeed<T> FromKilohertz(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ClockSpeed from a value in Megahertz.
 	/// </summary>
 	/// <param name="value">The value in Megahertz.</param>
 	/// <returns>A new ClockSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ClockSpeed<T> FromMegahertz(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Mega)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Frequency unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IFrequencyUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Frequency.</summary>
+
+	/// <summary>Implicit conversion to Frequency.</summary>
 	public static implicit operator Frequency<T>(ClockSpeed<T> value) => Frequency<T>.Create(value.Value);
-/// <summary>Explicit conversion from Frequency.</summary>
+
+	/// <summary>Explicit conversion from Frequency.</summary>
 	public static explicit operator ClockSpeed<T>(Frequency<T> value) => Create(value.Value);
-/// <summary>Creates a ClockSpeed from a Frequency value.</summary>
+
+	/// <summary>Creates a ClockSpeed from a Frequency value.</summary>
 	public static ClockSpeed<T> From(Frequency<T> value) => Create(value.Value);
-/// <summary>Subtracts two ClockSpeed values, returning the absolute difference as a non-negative ClockSpeed.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ClockSpeed<T> operator -(ClockSpeed<T> left, ClockSpeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two ClockSpeed values, returning the absolute difference as a non-negative ClockSpeed.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ClockSpeed<T> operator -(ClockSpeed<T> left, ClockSpeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Concentration.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Concentration.g.cs
index 8ba243d0..82247050 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Concentration.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Concentration.g.cs
@@ -25,50 +25,62 @@ public partial record Concentration<T> : PhysicalQuantity<Concentration<T>, T>,
 	/// <returns>A new <see cref="Concentration{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Concentration<T> FromMolePerCubicMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Concentration{T}"/> from a value in Molar.
 	/// </summary>
 	/// <param name="value">The value in Molar.</param>
 	/// <returns>A new <see cref="Concentration{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Concentration<T> FromMolar(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MolarToCubicMeter)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Concentration{T}"/> from a value in Millimolar.
 	/// </summary>
 	/// <param name="value">The value in Millimolar.</param>
 	/// <returns>A new <see cref="Concentration{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Concentration<T> FromMillimolar(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MillimolarToMolePerCubicMeter)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Concentration{T}"/> from a value in Micromolar.
 	/// </summary>
 	/// <param name="value">The value in Micromolar.</param>
 	/// <returns>A new <see cref="Concentration{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Concentration<T> FromMicromolar(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MicromolarToMolePerCubicMeter)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Concentration unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IConcentrationUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Concentration values, returning the absolute difference as a non-negative Concentration.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Concentration<T> operator -(Concentration<T> left, Concentration<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Concentration<T> operator -(Concentration<T> left, Concentration<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Concentration by Volume to produce AmountOfSubstance.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AmountOfSubstance<T> operator *(Concentration<T> left, Volume<T> right) => Multiply<AmountOfSubstance<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator *(Concentration<T> left, Volume<T> right) => Multiply<AmountOfSubstance<T>>(left, right);
+
+	/// <summary>
 	/// Divides Concentration by Duration to produce ReactionRate.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ReactionRate<T> operator /(Concentration<T> left, Duration<T> right) => Divide<ReactionRate<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ReactionRate<T> operator /(Concentration<T> left, Duration<T> right) => Divide<ReactionRate<T>>(left, right);
+
+	/// <summary>
 	/// Divides Concentration by ReactionRate to produce Duration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Duration<T> operator /(Concentration<T> left, ReactionRate<T> right) => Divide<Duration<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Concentration<T> left, ReactionRate<T> right) => Divide<Duration<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Conductance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Conductance.g.cs
index 437274d8..6603bb42 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Conductance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Conductance.g.cs
@@ -25,21 +25,26 @@ public partial record Conductance<T> : PhysicalQuantity<Conductance<T>, T>, IVec
 	/// <returns>A new <see cref="Conductance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Conductance<T> FromSiemens(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricConductance unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricConductanceUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Conductance values, returning the absolute difference as a non-negative Conductance.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Conductance<T> operator -(Conductance<T> left, Conductance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Conductance<T> operator -(Conductance<T> left, Conductance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Conductance by VoltageMagnitude to produce CurrentMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static CurrentMagnitude<T> operator *(Conductance<T> left, VoltageMagnitude<T> right) => Multiply<CurrentMagnitude<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static CurrentMagnitude<T> operator *(Conductance<T> left, VoltageMagnitude<T> right) => Multiply<CurrentMagnitude<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CrossSectionalArea.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CrossSectionalArea.g.cs
index 50447379..84f2b19a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CrossSectionalArea.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CrossSectionalArea.g.cs
@@ -26,69 +26,82 @@ public partial record CrossSectionalArea<T> : PhysicalQuantity<CrossSectionalAre
 	/// <returns>A new CrossSectionalArea instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static CrossSectionalArea<T> FromSquareMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new CrossSectionalArea from a value in SquareKilometer.
 	/// </summary>
 	/// <param name="value">The value in SquareKilometer.</param>
 	/// <returns>A new CrossSectionalArea instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static CrossSectionalArea<T> FromSquareKilometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.SquareKilometerToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new CrossSectionalArea from a value in SquareCentimeter.
 	/// </summary>
 	/// <param name="value">The value in SquareCentimeter.</param>
 	/// <returns>A new CrossSectionalArea instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static CrossSectionalArea<T> FromSquareCentimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.SquareCentimeterToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new CrossSectionalArea from a value in SquareFoot.
 	/// </summary>
 	/// <param name="value">The value in SquareFoot.</param>
 	/// <returns>A new CrossSectionalArea instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static CrossSectionalArea<T> FromSquareFoot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.SquareFootToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new CrossSectionalArea from a value in SquareInch.
 	/// </summary>
 	/// <param name="value">The value in SquareInch.</param>
 	/// <returns>A new CrossSectionalArea instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static CrossSectionalArea<T> FromSquareInch(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.SquareInchToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new CrossSectionalArea from a value in SquareMile.
 	/// </summary>
 	/// <param name="value">The value in SquareMile.</param>
 	/// <returns>A new CrossSectionalArea instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static CrossSectionalArea<T> FromSquareMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.SquareMileToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new CrossSectionalArea from a value in Hectare.
 	/// </summary>
 	/// <param name="value">The value in Hectare.</param>
 	/// <returns>A new CrossSectionalArea instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static CrossSectionalArea<T> FromHectare(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.HectareToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new CrossSectionalArea from a value in Acre.
 	/// </summary>
 	/// <param name="value">The value in Acre.</param>
 	/// <returns>A new CrossSectionalArea instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static CrossSectionalArea<T> FromAcre(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AcreToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Area unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAreaUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Area.</summary>
+
+	/// <summary>Implicit conversion to Area.</summary>
 	public static implicit operator Area<T>(CrossSectionalArea<T> value) => Area<T>.Create(value.Value);
-/// <summary>Explicit conversion from Area.</summary>
+
+	/// <summary>Explicit conversion from Area.</summary>
 	public static explicit operator CrossSectionalArea<T>(Area<T> value) => Create(value.Value);
-/// <summary>Creates a CrossSectionalArea from a Area value.</summary>
+
+	/// <summary>Creates a CrossSectionalArea from a Area value.</summary>
 	public static CrossSectionalArea<T> From(Area<T> value) => Create(value.Value);
-/// <summary>Subtracts two CrossSectionalArea values, returning the absolute difference as a non-negative CrossSectionalArea.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static CrossSectionalArea<T> operator -(CrossSectionalArea<T> left, CrossSectionalArea<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two CrossSectionalArea values, returning the absolute difference as a non-negative CrossSectionalArea.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static CrossSectionalArea<T> operator -(CrossSectionalArea<T> left, CrossSectionalArea<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Current1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Current1D.g.cs
index 742d2026..eb60754e 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Current1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Current1D.g.cs
@@ -24,37 +24,45 @@ public partial record Current1D<T> : PhysicalQuantity<Current1D<T>, T>, IVector1
 	/// <param name="value">The value in Ampere.</param>
 	/// <returns>A new <see cref="Current1D{T}"/> instance.</returns>
 	public static Current1D<T> FromAmpere(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Current1D{T}"/> from a value in Milliampere.
 	/// </summary>
 	/// <param name="value">The value in Milliampere.</param>
 	/// <returns>A new <see cref="Current1D{T}"/> instance.</returns>
 	public static Current1D<T> FromMilliampere(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Milli)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Current1D{T}"/> from a value in Kiloampere.
 	/// </summary>
 	/// <param name="value">The value in Kiloampere.</param>
 	/// <returns>A new <see cref="Current1D{T}"/> instance.</returns>
 	public static Current1D<T> FromKiloampere(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Kilo)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricCurrent unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricCurrentUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="CurrentMagnitude{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public CurrentMagnitude<T> Magnitude() => CurrentMagnitude<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Multiplies Current1D by Duration to produce Charge.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Charge<T> operator *(Current1D<T> left, Duration<T> right) => Multiply<Charge<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Charge<T> operator *(Current1D<T> left, Duration<T> right) => Multiply<Charge<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Current1D by Resistance to produce Voltage.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Voltage<T> operator *(Current1D<T> left, Resistance<T> right) => Multiply<Voltage<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Voltage<T> operator *(Current1D<T> left, Resistance<T> right) => Multiply<Voltage<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CurrentMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CurrentMagnitude.g.cs
index 8e27ab0b..363ebaf8 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CurrentMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CurrentMagnitude.g.cs
@@ -25,55 +25,72 @@ public partial record CurrentMagnitude<T> : PhysicalQuantity<CurrentMagnitude<T>
 	/// <returns>A new <see cref="CurrentMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static CurrentMagnitude<T> FromAmpere(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="CurrentMagnitude{T}"/> from a value in Milliampere.
 	/// </summary>
 	/// <param name="value">The value in Milliampere.</param>
 	/// <returns>A new <see cref="CurrentMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static CurrentMagnitude<T> FromMilliampere(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="CurrentMagnitude{T}"/> from a value in Kiloampere.
 	/// </summary>
 	/// <param name="value">The value in Kiloampere.</param>
 	/// <returns>A new <see cref="CurrentMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static CurrentMagnitude<T> FromKiloampere(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricCurrent unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricCurrentUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two CurrentMagnitude values, returning the absolute difference as a non-negative CurrentMagnitude.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static CurrentMagnitude<T> operator -(CurrentMagnitude<T> left, CurrentMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static CurrentMagnitude<T> operator -(CurrentMagnitude<T> left, CurrentMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies CurrentMagnitude by Duration to produce ChargeMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ChargeMagnitude<T> operator *(CurrentMagnitude<T> left, Duration<T> right) => Multiply<ChargeMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ChargeMagnitude<T> operator *(CurrentMagnitude<T> left, Duration<T> right) => Multiply<ChargeMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies CurrentMagnitude by Resistance to produce VoltageMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static VoltageMagnitude<T> operator *(CurrentMagnitude<T> left, Resistance<T> right) => Multiply<VoltageMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(CurrentMagnitude<T> left, Resistance<T> right) => Multiply<VoltageMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies CurrentMagnitude by VoltageMagnitude to produce Power.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Power<T> operator *(CurrentMagnitude<T> left, VoltageMagnitude<T> right) => Multiply<Power<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(CurrentMagnitude<T> left, VoltageMagnitude<T> right) => Multiply<Power<T>>(left, right);
+
+	/// <summary>
 	/// Divides CurrentMagnitude by VoltageMagnitude to produce Conductance.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Conductance<T> operator /(CurrentMagnitude<T> left, VoltageMagnitude<T> right) => Divide<Conductance<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Conductance<T> operator /(CurrentMagnitude<T> left, VoltageMagnitude<T> right) => Divide<Conductance<T>>(left, right);
+
+	/// <summary>
 	/// Divides CurrentMagnitude by Conductance to produce VoltageMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static VoltageMagnitude<T> operator /(CurrentMagnitude<T> left, Conductance<T> right) => Divide<VoltageMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator /(CurrentMagnitude<T> left, Conductance<T> right) => Divide<VoltageMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies CurrentMagnitude by Inductance to produce MagneticFlux.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MagneticFlux<T> operator *(CurrentMagnitude<T> left, Inductance<T> right) => Multiply<MagneticFlux<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFlux<T> operator *(CurrentMagnitude<T> left, Inductance<T> right) => Multiply<MagneticFlux<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/DecayTime.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/DecayTime.g.cs
index 0359db40..45de94f4 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/DecayTime.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/DecayTime.g.cs
@@ -26,76 +26,90 @@ public partial record DecayTime<T> : PhysicalQuantity<DecayTime<T>, T>, IVector0
 	/// <returns>A new DecayTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static DecayTime<T> FromSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new DecayTime from a value in Millisecond.
 	/// </summary>
 	/// <param name="value">The value in Millisecond.</param>
 	/// <returns>A new DecayTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static DecayTime<T> FromMillisecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new DecayTime from a value in Microsecond.
 	/// </summary>
 	/// <param name="value">The value in Microsecond.</param>
 	/// <returns>A new DecayTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static DecayTime<T> FromMicrosecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new DecayTime from a value in Minute.
 	/// </summary>
 	/// <param name="value">The value in Minute.</param>
 	/// <returns>A new DecayTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static DecayTime<T> FromMinute(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MinuteToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new DecayTime from a value in Hour.
 	/// </summary>
 	/// <param name="value">The value in Hour.</param>
 	/// <returns>A new DecayTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static DecayTime<T> FromHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.HourToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new DecayTime from a value in Day.
 	/// </summary>
 	/// <param name="value">The value in Day.</param>
 	/// <returns>A new DecayTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static DecayTime<T> FromDay(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DayToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new DecayTime from a value in Year.
 	/// </summary>
 	/// <param name="value">The value in Year.</param>
 	/// <returns>A new DecayTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static DecayTime<T> FromYear(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YearToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new DecayTime from a value in Week.
 	/// </summary>
 	/// <param name="value">The value in Week.</param>
 	/// <returns>A new DecayTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static DecayTime<T> FromWeek(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.WeekToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new DecayTime from a value in Nanosecond.
 	/// </summary>
 	/// <param name="value">The value in Nanosecond.</param>
 	/// <returns>A new DecayTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static DecayTime<T> FromNanosecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Time unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ITimeUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Duration.</summary>
+
+	/// <summary>Implicit conversion to Duration.</summary>
 	public static implicit operator Duration<T>(DecayTime<T> value) => Duration<T>.Create(value.Value);
-/// <summary>Explicit conversion from Duration.</summary>
+
+	/// <summary>Explicit conversion from Duration.</summary>
 	public static explicit operator DecayTime<T>(Duration<T> value) => Create(value.Value);
-/// <summary>Creates a DecayTime from a Duration value.</summary>
+
+	/// <summary>Creates a DecayTime from a Duration value.</summary>
 	public static DecayTime<T> From(Duration<T> value) => Create(value.Value);
-/// <summary>Subtracts two DecayTime values, returning the absolute difference as a non-negative DecayTime.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static DecayTime<T> operator -(DecayTime<T> left, DecayTime<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two DecayTime values, returning the absolute difference as a non-negative DecayTime.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static DecayTime<T> operator -(DecayTime<T> left, DecayTime<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Density.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Density.g.cs
index 68506b6d..261866b9 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Density.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Density.g.cs
@@ -25,39 +25,48 @@ public partial record Density<T> : PhysicalQuantity<Density<T>, T>, IVector0<Den
 	/// <returns>A new <see cref="Density{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Density<T> FromKilogramPerCubicMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Density{T}"/> from a value in GramPerCubicCentimeter.
 	/// </summary>
 	/// <param name="value">The value in GramPerCubicCentimeter.</param>
 	/// <returns>A new <see cref="Density{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Density<T> FromGramPerCubicCentimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GramPerCubicCentimeterToKilogramPerCubicMeter)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Density{T}"/> from a value in GramPerLiter.
 	/// </summary>
 	/// <param name="value">The value in GramPerLiter.</param>
 	/// <returns>A new <see cref="Density{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Density<T> FromGramPerLiter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GramPerLiterToKilogramPerCubicMeter)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Density unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IDensityUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Density values, returning the absolute difference as a non-negative Density.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Density<T> operator -(Density<T> left, Density<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Density<T> operator -(Density<T> left, Density<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Density by Volume to produce Mass.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Mass<T> operator *(Density<T> left, Volume<T> right) => Multiply<Mass<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator *(Density<T> left, Volume<T> right) => Multiply<Mass<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Density by KinematicViscosity to produce DynamicViscosity.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static DynamicViscosity<T> operator *(Density<T> left, KinematicViscosity<T> right) => Multiply<DynamicViscosity<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static DynamicViscosity<T> operator *(Density<T> left, KinematicViscosity<T> right) => Multiply<DynamicViscosity<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Depth.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Depth.g.cs
index 8c34e77b..e5a0a085 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Depth.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Depth.g.cs
@@ -26,97 +26,114 @@ public partial record Depth<T> : PhysicalQuantity<Depth<T>, T>, IVector0<Depth<T
 	/// <returns>A new Depth instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Depth<T> FromMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Depth from a value in Kilometer.
 	/// </summary>
 	/// <param name="value">The value in Kilometer.</param>
 	/// <returns>A new Depth instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Depth<T> FromKilometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Depth from a value in Centimeter.
 	/// </summary>
 	/// <param name="value">The value in Centimeter.</param>
 	/// <returns>A new Depth instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Depth<T> FromCentimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Centi)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Depth from a value in Millimeter.
 	/// </summary>
 	/// <param name="value">The value in Millimeter.</param>
 	/// <returns>A new Depth instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Depth<T> FromMillimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Depth from a value in Micrometer.
 	/// </summary>
 	/// <param name="value">The value in Micrometer.</param>
 	/// <returns>A new Depth instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Depth<T> FromMicrometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Depth from a value in Nanometer.
 	/// </summary>
 	/// <param name="value">The value in Nanometer.</param>
 	/// <returns>A new Depth instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Depth<T> FromNanometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Depth from a value in Angstrom.
 	/// </summary>
 	/// <param name="value">The value in Angstrom.</param>
 	/// <returns>A new Depth instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Depth<T> FromAngstrom(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AngstromToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Depth from a value in Foot.
 	/// </summary>
 	/// <param name="value">The value in Foot.</param>
 	/// <returns>A new Depth instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Depth<T> FromFoot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FeetToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Depth from a value in Inch.
 	/// </summary>
 	/// <param name="value">The value in Inch.</param>
 	/// <returns>A new Depth instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Depth<T> FromInch(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.InchesToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Depth from a value in Yard.
 	/// </summary>
 	/// <param name="value">The value in Yard.</param>
 	/// <returns>A new Depth instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Depth<T> FromYard(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YardToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Depth from a value in Mile.
 	/// </summary>
 	/// <param name="value">The value in Mile.</param>
 	/// <returns>A new Depth instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Depth<T> FromMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Depth from a value in NauticalMile.
 	/// </summary>
 	/// <param name="value">The value in NauticalMile.</param>
 	/// <returns>A new Depth instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Depth<T> FromNauticalMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.NauticalMileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Length unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Length.</summary>
+
+	/// <summary>Implicit conversion to Length.</summary>
 	public static implicit operator Length<T>(Depth<T> value) => Length<T>.Create(value.Value);
-/// <summary>Explicit conversion from Length.</summary>
+
+	/// <summary>Explicit conversion from Length.</summary>
 	public static explicit operator Depth<T>(Length<T> value) => Create(value.Value);
-/// <summary>Creates a Depth from a Length value.</summary>
+
+	/// <summary>Creates a Depth from a Length value.</summary>
 	public static Depth<T> From(Length<T> value) => Create(value.Value);
-/// <summary>Subtracts two Depth values, returning the absolute difference as a non-negative Depth.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Depth<T> operator -(Depth<T> left, Depth<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Depth values, returning the absolute difference as a non-negative Depth.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Depth<T> operator -(Depth<T> left, Depth<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Diameter.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Diameter.g.cs
index f8f41d12..5eb612ec 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Diameter.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Diameter.g.cs
@@ -26,101 +26,120 @@ public partial record Diameter<T> : PhysicalQuantity<Diameter<T>, T>, IVector0<D
 	/// <returns>A new Diameter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Diameter<T> FromMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Diameter from a value in Kilometer.
 	/// </summary>
 	/// <param name="value">The value in Kilometer.</param>
 	/// <returns>A new Diameter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Diameter<T> FromKilometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Diameter from a value in Centimeter.
 	/// </summary>
 	/// <param name="value">The value in Centimeter.</param>
 	/// <returns>A new Diameter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Diameter<T> FromCentimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Centi)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Diameter from a value in Millimeter.
 	/// </summary>
 	/// <param name="value">The value in Millimeter.</param>
 	/// <returns>A new Diameter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Diameter<T> FromMillimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Diameter from a value in Micrometer.
 	/// </summary>
 	/// <param name="value">The value in Micrometer.</param>
 	/// <returns>A new Diameter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Diameter<T> FromMicrometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Diameter from a value in Nanometer.
 	/// </summary>
 	/// <param name="value">The value in Nanometer.</param>
 	/// <returns>A new Diameter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Diameter<T> FromNanometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Diameter from a value in Angstrom.
 	/// </summary>
 	/// <param name="value">The value in Angstrom.</param>
 	/// <returns>A new Diameter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Diameter<T> FromAngstrom(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AngstromToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Diameter from a value in Foot.
 	/// </summary>
 	/// <param name="value">The value in Foot.</param>
 	/// <returns>A new Diameter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Diameter<T> FromFoot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FeetToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Diameter from a value in Inch.
 	/// </summary>
 	/// <param name="value">The value in Inch.</param>
 	/// <returns>A new Diameter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Diameter<T> FromInch(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.InchesToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Diameter from a value in Yard.
 	/// </summary>
 	/// <param name="value">The value in Yard.</param>
 	/// <returns>A new Diameter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Diameter<T> FromYard(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YardToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Diameter from a value in Mile.
 	/// </summary>
 	/// <param name="value">The value in Mile.</param>
 	/// <returns>A new Diameter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Diameter<T> FromMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Diameter from a value in NauticalMile.
 	/// </summary>
 	/// <param name="value">The value in NauticalMile.</param>
 	/// <returns>A new Diameter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Diameter<T> FromNauticalMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.NauticalMileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Length unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Length.</summary>
+
+	/// <summary>Implicit conversion to Length.</summary>
 	public static implicit operator Length<T>(Diameter<T> value) => Length<T>.Create(value.Value);
-/// <summary>Explicit conversion from Length.</summary>
+
+	/// <summary>Explicit conversion from Length.</summary>
 	public static explicit operator Diameter<T>(Length<T> value) => Create(value.Value);
-/// <summary>Creates a Diameter from a Length value.</summary>
+
+	/// <summary>Creates a Diameter from a Length value.</summary>
 	public static Diameter<T> From(Length<T> value) => Create(value.Value);
-/// <summary>Subtracts two Diameter values, returning the absolute difference as a non-negative Diameter.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Diameter<T> operator -(Diameter<T> left, Diameter<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>Converts this Diameter to a Radius.</summary>
+
+	/// <summary>Subtracts two Diameter values, returning the absolute difference as a non-negative Diameter.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Diameter<T> operator -(Diameter<T> left, Diameter<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Converts this Diameter to a Radius.</summary>
 	public Radius<T> ToRadius() => Radius<T>.Create(Value / T.CreateChecked(2));
-/// <summary>Creates a Diameter from a Radius value.</summary>
+
+	/// <summary>Creates a Diameter from a Radius value.</summary>
 	public static Diameter<T> FromRadius(Radius<T> source) => Create(source.Value * T.CreateChecked(2));
-};
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement1D.g.cs
index c7d856ba..29725f5f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement1D.g.cs
@@ -24,87 +24,102 @@ public partial record Displacement1D<T> : PhysicalQuantity<Displacement1D<T>, T>
 	/// <param name="value">The value in Meter.</param>
 	/// <returns>A new <see cref="Displacement1D{T}"/> instance.</returns>
 	public static Displacement1D<T> FromMeter(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Displacement1D{T}"/> from a value in Kilometer.
 	/// </summary>
 	/// <param name="value">The value in Kilometer.</param>
 	/// <returns>A new <see cref="Displacement1D{T}"/> instance.</returns>
 	public static Displacement1D<T> FromKilometer(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Kilo)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Displacement1D{T}"/> from a value in Centimeter.
 	/// </summary>
 	/// <param name="value">The value in Centimeter.</param>
 	/// <returns>A new <see cref="Displacement1D{T}"/> instance.</returns>
 	public static Displacement1D<T> FromCentimeter(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Centi)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Displacement1D{T}"/> from a value in Millimeter.
 	/// </summary>
 	/// <param name="value">The value in Millimeter.</param>
 	/// <returns>A new <see cref="Displacement1D{T}"/> instance.</returns>
 	public static Displacement1D<T> FromMillimeter(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Milli)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Displacement1D{T}"/> from a value in Micrometer.
 	/// </summary>
 	/// <param name="value">The value in Micrometer.</param>
 	/// <returns>A new <see cref="Displacement1D{T}"/> instance.</returns>
 	public static Displacement1D<T> FromMicrometer(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Micro)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Displacement1D{T}"/> from a value in Nanometer.
 	/// </summary>
 	/// <param name="value">The value in Nanometer.</param>
 	/// <returns>A new <see cref="Displacement1D{T}"/> instance.</returns>
 	public static Displacement1D<T> FromNanometer(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Nano)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Displacement1D{T}"/> from a value in Angstrom.
 	/// </summary>
 	/// <param name="value">The value in Angstrom.</param>
 	/// <returns>A new <see cref="Displacement1D{T}"/> instance.</returns>
 	public static Displacement1D<T> FromAngstrom(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.AngstromToMeters)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Displacement1D{T}"/> from a value in Foot.
 	/// </summary>
 	/// <param name="value">The value in Foot.</param>
 	/// <returns>A new <see cref="Displacement1D{T}"/> instance.</returns>
 	public static Displacement1D<T> FromFoot(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.FeetToMeters)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Displacement1D{T}"/> from a value in Inch.
 	/// </summary>
 	/// <param name="value">The value in Inch.</param>
 	/// <returns>A new <see cref="Displacement1D{T}"/> instance.</returns>
 	public static Displacement1D<T> FromInch(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.InchesToMeters)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Displacement1D{T}"/> from a value in Yard.
 	/// </summary>
 	/// <param name="value">The value in Yard.</param>
 	/// <returns>A new <see cref="Displacement1D{T}"/> instance.</returns>
 	public static Displacement1D<T> FromYard(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.YardToMeters)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Displacement1D{T}"/> from a value in Mile.
 	/// </summary>
 	/// <param name="value">The value in Mile.</param>
 	/// <returns>A new <see cref="Displacement1D{T}"/> instance.</returns>
 	public static Displacement1D<T> FromMile(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.MileToMeters)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Displacement1D{T}"/> from a value in NauticalMile.
 	/// </summary>
 	/// <param name="value">The value in NauticalMile.</param>
 	/// <returns>A new <see cref="Displacement1D{T}"/> instance.</returns>
 	public static Displacement1D<T> FromNauticalMile(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.NauticalMileToMeters)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Length unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="Length{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public Length<T> Magnitude() => Length<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Divides Displacement1D by Duration to produce Velocity1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Velocity1D<T> operator /(Displacement1D<T> left, Duration<T> right) => Divide<Velocity1D<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity1D<T> operator /(Displacement1D<T> left, Duration<T> right) => Divide<Velocity1D<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Distance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Distance.g.cs
index c7806ffd..975fef81 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Distance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Distance.g.cs
@@ -26,97 +26,114 @@ public partial record Distance<T> : PhysicalQuantity<Distance<T>, T>, IVector0<D
 	/// <returns>A new Distance instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Distance<T> FromMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Distance from a value in Kilometer.
 	/// </summary>
 	/// <param name="value">The value in Kilometer.</param>
 	/// <returns>A new Distance instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Distance<T> FromKilometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Distance from a value in Centimeter.
 	/// </summary>
 	/// <param name="value">The value in Centimeter.</param>
 	/// <returns>A new Distance instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Distance<T> FromCentimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Centi)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Distance from a value in Millimeter.
 	/// </summary>
 	/// <param name="value">The value in Millimeter.</param>
 	/// <returns>A new Distance instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Distance<T> FromMillimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Distance from a value in Micrometer.
 	/// </summary>
 	/// <param name="value">The value in Micrometer.</param>
 	/// <returns>A new Distance instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Distance<T> FromMicrometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Distance from a value in Nanometer.
 	/// </summary>
 	/// <param name="value">The value in Nanometer.</param>
 	/// <returns>A new Distance instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Distance<T> FromNanometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Distance from a value in Angstrom.
 	/// </summary>
 	/// <param name="value">The value in Angstrom.</param>
 	/// <returns>A new Distance instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Distance<T> FromAngstrom(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AngstromToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Distance from a value in Foot.
 	/// </summary>
 	/// <param name="value">The value in Foot.</param>
 	/// <returns>A new Distance instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Distance<T> FromFoot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FeetToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Distance from a value in Inch.
 	/// </summary>
 	/// <param name="value">The value in Inch.</param>
 	/// <returns>A new Distance instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Distance<T> FromInch(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.InchesToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Distance from a value in Yard.
 	/// </summary>
 	/// <param name="value">The value in Yard.</param>
 	/// <returns>A new Distance instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Distance<T> FromYard(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YardToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Distance from a value in Mile.
 	/// </summary>
 	/// <param name="value">The value in Mile.</param>
 	/// <returns>A new Distance instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Distance<T> FromMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Distance from a value in NauticalMile.
 	/// </summary>
 	/// <param name="value">The value in NauticalMile.</param>
 	/// <returns>A new Distance instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Distance<T> FromNauticalMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.NauticalMileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Length unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Length.</summary>
+
+	/// <summary>Implicit conversion to Length.</summary>
 	public static implicit operator Length<T>(Distance<T> value) => Length<T>.Create(value.Value);
-/// <summary>Explicit conversion from Length.</summary>
+
+	/// <summary>Explicit conversion from Length.</summary>
 	public static explicit operator Distance<T>(Length<T> value) => Create(value.Value);
-/// <summary>Creates a Distance from a Length value.</summary>
+
+	/// <summary>Creates a Distance from a Length value.</summary>
 	public static Distance<T> From(Length<T> value) => Create(value.Value);
-/// <summary>Subtracts two Distance values, returning the absolute difference as a non-negative Distance.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Distance<T> operator -(Distance<T> left, Distance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Distance values, returning the absolute difference as a non-negative Distance.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Distance<T> operator -(Distance<T> left, Distance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Drag.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Drag.g.cs
index 5600e98b..bee778d8 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Drag.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Drag.g.cs
@@ -26,41 +26,50 @@ public partial record Drag<T> : PhysicalQuantity<Drag<T>, T>, IVector0<Drag<T>,
 	/// <returns>A new Drag instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Drag<T> FromNewton(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Drag from a value in Kilonewton.
 	/// </summary>
 	/// <param name="value">The value in Kilonewton.</param>
 	/// <returns>A new Drag instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Drag<T> FromKilonewton(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Drag from a value in Dyne.
 	/// </summary>
 	/// <param name="value">The value in Dyne.</param>
 	/// <returns>A new Drag instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Drag<T> FromDyne(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DyneToNewtons)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Drag from a value in PoundForce.
 	/// </summary>
 	/// <param name="value">The value in PoundForce.</param>
 	/// <returns>A new Drag instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Drag<T> FromPoundForce(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PoundForceToNewtons)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Force unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IForceUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to ForceMagnitude.</summary>
+
+	/// <summary>Implicit conversion to ForceMagnitude.</summary>
 	public static implicit operator ForceMagnitude<T>(Drag<T> value) => ForceMagnitude<T>.Create(value.Value);
-/// <summary>Explicit conversion from ForceMagnitude.</summary>
+
+	/// <summary>Explicit conversion from ForceMagnitude.</summary>
 	public static explicit operator Drag<T>(ForceMagnitude<T> value) => Create(value.Value);
-/// <summary>Creates a Drag from a ForceMagnitude value.</summary>
+
+	/// <summary>Creates a Drag from a ForceMagnitude value.</summary>
 	public static Drag<T> From(ForceMagnitude<T> value) => Create(value.Value);
-/// <summary>Subtracts two Drag values, returning the absolute difference as a non-negative Drag.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Drag<T> operator -(Drag<T> left, Drag<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Drag values, returning the absolute difference as a non-negative Drag.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Drag<T> operator -(Drag<T> left, Drag<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Duration.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Duration.g.cs
index 7001b078..699cf3da 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Duration.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Duration.g.cs
@@ -25,257 +25,360 @@ public partial record Duration<T> : PhysicalQuantity<Duration<T>, T>, IVector0<D
 	/// <returns>A new <see cref="Duration{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Duration<T> FromSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Duration{T}"/> from a value in Millisecond.
 	/// </summary>
 	/// <param name="value">The value in Millisecond.</param>
 	/// <returns>A new <see cref="Duration{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Duration<T> FromMillisecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Duration{T}"/> from a value in Microsecond.
 	/// </summary>
 	/// <param name="value">The value in Microsecond.</param>
 	/// <returns>A new <see cref="Duration{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Duration<T> FromMicrosecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Duration{T}"/> from a value in Minute.
 	/// </summary>
 	/// <param name="value">The value in Minute.</param>
 	/// <returns>A new <see cref="Duration{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Duration<T> FromMinute(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MinuteToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Duration{T}"/> from a value in Hour.
 	/// </summary>
 	/// <param name="value">The value in Hour.</param>
 	/// <returns>A new <see cref="Duration{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Duration<T> FromHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.HourToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Duration{T}"/> from a value in Day.
 	/// </summary>
 	/// <param name="value">The value in Day.</param>
 	/// <returns>A new <see cref="Duration{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Duration<T> FromDay(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DayToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Duration{T}"/> from a value in Year.
 	/// </summary>
 	/// <param name="value">The value in Year.</param>
 	/// <returns>A new <see cref="Duration{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Duration<T> FromYear(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YearToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Duration{T}"/> from a value in Week.
 	/// </summary>
 	/// <param name="value">The value in Week.</param>
 	/// <returns>A new <see cref="Duration{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Duration<T> FromWeek(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.WeekToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Duration{T}"/> from a value in Nanosecond.
 	/// </summary>
 	/// <param name="value">The value in Nanosecond.</param>
 	/// <returns>A new <see cref="Duration{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Duration<T> FromNanosecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Time unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ITimeUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Duration values, returning the absolute difference as a non-negative Duration.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Duration<T> operator -(Duration<T> left, Duration<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator -(Duration<T> left, Duration<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Duration by CurrentMagnitude to produce ChargeMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ChargeMagnitude<T> operator *(Duration<T> left, CurrentMagnitude<T> right) => Multiply<ChargeMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ChargeMagnitude<T> operator *(Duration<T> left, CurrentMagnitude<T> right) => Multiply<ChargeMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by Current1D to produce Charge.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Charge<T> operator *(Duration<T> left, Current1D<T> right) => Multiply<Charge<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Charge<T> operator *(Duration<T> left, Current1D<T> right) => Multiply<Charge<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by Speed to produce Length.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Length<T> operator *(Duration<T> left, Speed<T> right) => Multiply<Length<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator *(Duration<T> left, Speed<T> right) => Multiply<Length<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by Velocity1D to produce Displacement1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Displacement1D<T> operator *(Duration<T> left, Velocity1D<T> right) => Multiply<Displacement1D<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement1D<T> operator *(Duration<T> left, Velocity1D<T> right) => Multiply<Displacement1D<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by Velocity2D to produce Displacement2D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Displacement2D<T> operator *(Duration<T> left, Velocity2D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement2D<T> operator *(Duration<T> left, Velocity2D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y };
+
+	/// <summary>
 	/// Multiplies Duration by Velocity3D to produce Displacement3D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Displacement3D<T> operator *(Duration<T> left, Velocity3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement3D<T> operator *(Duration<T> left, Velocity3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
+
+	/// <summary>
 	/// Multiplies Duration by Velocity4D to produce Displacement4D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Displacement4D<T> operator *(Duration<T> left, Velocity4D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z, W = left.Value * right.W };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement4D<T> operator *(Duration<T> left, Velocity4D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z, W = left.Value * right.W };
+
+	/// <summary>
 	/// Multiplies Duration by AccelerationMagnitude to produce Speed.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Speed<T> operator *(Duration<T> left, AccelerationMagnitude<T> right) => Multiply<Speed<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(Duration<T> left, AccelerationMagnitude<T> right) => Multiply<Speed<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by Acceleration1D to produce Velocity1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Velocity1D<T> operator *(Duration<T> left, Acceleration1D<T> right) => Multiply<Velocity1D<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity1D<T> operator *(Duration<T> left, Acceleration1D<T> right) => Multiply<Velocity1D<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by Acceleration2D to produce Velocity2D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Velocity2D<T> operator *(Duration<T> left, Acceleration2D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity2D<T> operator *(Duration<T> left, Acceleration2D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y };
+
+	/// <summary>
 	/// Multiplies Duration by Acceleration3D to produce Velocity3D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Velocity3D<T> operator *(Duration<T> left, Acceleration3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity3D<T> operator *(Duration<T> left, Acceleration3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
+
+	/// <summary>
 	/// Multiplies Duration by Acceleration4D to produce Velocity4D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Velocity4D<T> operator *(Duration<T> left, Acceleration4D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z, W = left.Value * right.W };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity4D<T> operator *(Duration<T> left, Acceleration4D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z, W = left.Value * right.W };
+
+	/// <summary>
 	/// Multiplies Duration by JerkMagnitude to produce AccelerationMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AccelerationMagnitude<T> operator *(Duration<T> left, JerkMagnitude<T> right) => Multiply<AccelerationMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator *(Duration<T> left, JerkMagnitude<T> right) => Multiply<AccelerationMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by Jerk1D to produce Acceleration1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Acceleration1D<T> operator *(Duration<T> left, Jerk1D<T> right) => Multiply<Acceleration1D<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration1D<T> operator *(Duration<T> left, Jerk1D<T> right) => Multiply<Acceleration1D<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by Jerk2D to produce Acceleration2D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Acceleration2D<T> operator *(Duration<T> left, Jerk2D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration2D<T> operator *(Duration<T> left, Jerk2D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y };
+
+	/// <summary>
 	/// Multiplies Duration by Jerk3D to produce Acceleration3D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Acceleration3D<T> operator *(Duration<T> left, Jerk3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration3D<T> operator *(Duration<T> left, Jerk3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
+
+	/// <summary>
 	/// Multiplies Duration by Jerk4D to produce Acceleration4D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Acceleration4D<T> operator *(Duration<T> left, Jerk4D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z, W = left.Value * right.W };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration4D<T> operator *(Duration<T> left, Jerk4D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z, W = left.Value * right.W };
+
+	/// <summary>
 	/// Multiplies Duration by SnapMagnitude to produce JerkMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static JerkMagnitude<T> operator *(Duration<T> left, SnapMagnitude<T> right) => Multiply<JerkMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static JerkMagnitude<T> operator *(Duration<T> left, SnapMagnitude<T> right) => Multiply<JerkMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by Snap1D to produce Jerk1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Jerk1D<T> operator *(Duration<T> left, Snap1D<T> right) => Multiply<Jerk1D<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk1D<T> operator *(Duration<T> left, Snap1D<T> right) => Multiply<Jerk1D<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by Snap2D to produce Jerk2D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Jerk2D<T> operator *(Duration<T> left, Snap2D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk2D<T> operator *(Duration<T> left, Snap2D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y };
+
+	/// <summary>
 	/// Multiplies Duration by Snap3D to produce Jerk3D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Jerk3D<T> operator *(Duration<T> left, Snap3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk3D<T> operator *(Duration<T> left, Snap3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
+
+	/// <summary>
 	/// Multiplies Duration by Snap4D to produce Jerk4D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Jerk4D<T> operator *(Duration<T> left, Snap4D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z, W = left.Value * right.W };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk4D<T> operator *(Duration<T> left, Snap4D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z, W = left.Value * right.W };
+
+	/// <summary>
 	/// Multiplies Duration by Frequency to produce Ratio.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Ratio<T> operator *(Duration<T> left, Frequency<T> right) => Multiply<Ratio<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(Duration<T> left, Frequency<T> right) => Multiply<Ratio<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by AngularSpeed to produce Angle.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Angle<T> operator *(Duration<T> left, AngularSpeed<T> right) => Multiply<Angle<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Angle<T> operator *(Duration<T> left, AngularSpeed<T> right) => Multiply<Angle<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by AngularVelocity1D to produce SignedAngle.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SignedAngle<T> operator *(Duration<T> left, AngularVelocity1D<T> right) => Multiply<SignedAngle<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedAngle<T> operator *(Duration<T> left, AngularVelocity1D<T> right) => Multiply<SignedAngle<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by AngularVelocity3D to produce AngularDisplacement3D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularDisplacement3D<T> operator *(Duration<T> left, AngularVelocity3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularDisplacement3D<T> operator *(Duration<T> left, AngularVelocity3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
+
+	/// <summary>
 	/// Multiplies Duration by AngularAccelerationMagnitude to produce AngularSpeed.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularSpeed<T> operator *(Duration<T> left, AngularAccelerationMagnitude<T> right) => Multiply<AngularSpeed<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularSpeed<T> operator *(Duration<T> left, AngularAccelerationMagnitude<T> right) => Multiply<AngularSpeed<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by AngularAcceleration1D to produce AngularVelocity1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularVelocity1D<T> operator *(Duration<T> left, AngularAcceleration1D<T> right) => Multiply<AngularVelocity1D<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity1D<T> operator *(Duration<T> left, AngularAcceleration1D<T> right) => Multiply<AngularVelocity1D<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by AngularAcceleration3D to produce AngularVelocity3D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularVelocity3D<T> operator *(Duration<T> left, AngularAcceleration3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity3D<T> operator *(Duration<T> left, AngularAcceleration3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
+
+	/// <summary>
 	/// Multiplies Duration by AngularJerkMagnitude to produce AngularAccelerationMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularAccelerationMagnitude<T> operator *(Duration<T> left, AngularJerkMagnitude<T> right) => Multiply<AngularAccelerationMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAccelerationMagnitude<T> operator *(Duration<T> left, AngularJerkMagnitude<T> right) => Multiply<AngularAccelerationMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by AngularJerk1D to produce AngularAcceleration1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularAcceleration1D<T> operator *(Duration<T> left, AngularJerk1D<T> right) => Multiply<AngularAcceleration1D<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAcceleration1D<T> operator *(Duration<T> left, AngularJerk1D<T> right) => Multiply<AngularAcceleration1D<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by AngularJerk3D to produce AngularAcceleration3D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularAcceleration3D<T> operator *(Duration<T> left, AngularJerk3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAcceleration3D<T> operator *(Duration<T> left, AngularJerk3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
+
+	/// <summary>
 	/// Multiplies Duration by TorqueMagnitude to produce AngularMomentumMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularMomentumMagnitude<T> operator *(Duration<T> left, TorqueMagnitude<T> right) => Multiply<AngularMomentumMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentumMagnitude<T> operator *(Duration<T> left, TorqueMagnitude<T> right) => Multiply<AngularMomentumMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by Torque1D to produce AngularMomentum1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularMomentum1D<T> operator *(Duration<T> left, Torque1D<T> right) => Multiply<AngularMomentum1D<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentum1D<T> operator *(Duration<T> left, Torque1D<T> right) => Multiply<AngularMomentum1D<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by Torque3D to produce AngularMomentum3D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularMomentum3D<T> operator *(Duration<T> left, Torque3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentum3D<T> operator *(Duration<T> left, Torque3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
+
+	/// <summary>
 	/// Multiplies Duration by ForceMagnitude to produce MomentumMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MomentumMagnitude<T> operator *(Duration<T> left, ForceMagnitude<T> right) => Multiply<MomentumMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(Duration<T> left, ForceMagnitude<T> right) => Multiply<MomentumMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by Force1D to produce Momentum1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Momentum1D<T> operator *(Duration<T> left, Force1D<T> right) => Multiply<Momentum1D<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum1D<T> operator *(Duration<T> left, Force1D<T> right) => Multiply<Momentum1D<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by Force2D to produce Momentum2D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Momentum2D<T> operator *(Duration<T> left, Force2D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum2D<T> operator *(Duration<T> left, Force2D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y };
+
+	/// <summary>
 	/// Multiplies Duration by Force3D to produce Momentum3D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Momentum3D<T> operator *(Duration<T> left, Force3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum3D<T> operator *(Duration<T> left, Force3D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z };
+
+	/// <summary>
 	/// Multiplies Duration by Force4D to produce Momentum4D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Momentum4D<T> operator *(Duration<T> left, Force4D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z, W = left.Value * right.W };
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum4D<T> operator *(Duration<T> left, Force4D<T> right) => new() { X = left.Value * right.X, Y = left.Value * right.Y, Z = left.Value * right.Z, W = left.Value * right.W };
+
+	/// <summary>
 	/// Multiplies Duration by Power to produce Energy.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Energy<T> operator *(Duration<T> left, Power<T> right) => Multiply<Energy<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Duration<T> left, Power<T> right) => Multiply<Energy<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by VolumetricFlowRate to produce Volume.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Volume<T> operator *(Duration<T> left, VolumetricFlowRate<T> right) => Multiply<Volume<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(Duration<T> left, VolumetricFlowRate<T> right) => Multiply<Volume<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by MassFlowRate to produce Mass.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Mass<T> operator *(Duration<T> left, MassFlowRate<T> right) => Multiply<Mass<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator *(Duration<T> left, MassFlowRate<T> right) => Multiply<Mass<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by CatalyticActivity to produce AmountOfSubstance.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AmountOfSubstance<T> operator *(Duration<T> left, CatalyticActivity<T> right) => Multiply<AmountOfSubstance<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator *(Duration<T> left, CatalyticActivity<T> right) => Multiply<AmountOfSubstance<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by ReactionRate to produce Concentration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Concentration<T> operator *(Duration<T> left, ReactionRate<T> right) => Multiply<Concentration<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Concentration<T> operator *(Duration<T> left, ReactionRate<T> right) => Multiply<Concentration<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Duration by VoltageMagnitude to produce MagneticFlux.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MagneticFlux<T> operator *(Duration<T> left, VoltageMagnitude<T> right) => Multiply<MagneticFlux<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFlux<T> operator *(Duration<T> left, VoltageMagnitude<T> right) => Multiply<MagneticFlux<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/DynamicViscosity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/DynamicViscosity.g.cs
index c3e32d7a..910a720b 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/DynamicViscosity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/DynamicViscosity.g.cs
@@ -25,35 +25,42 @@ public partial record DynamicViscosity<T> : PhysicalQuantity<DynamicViscosity<T>
 	/// <returns>A new <see cref="DynamicViscosity{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static DynamicViscosity<T> FromPascalSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="DynamicViscosity{T}"/> from a value in Poise.
 	/// </summary>
 	/// <param name="value">The value in Poise.</param>
 	/// <returns>A new <see cref="DynamicViscosity{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static DynamicViscosity<T> FromPoise(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PoiseToPascalSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="DynamicViscosity{T}"/> from a value in Centipoise.
 	/// </summary>
 	/// <param name="value">The value in Centipoise.</param>
 	/// <returns>A new <see cref="DynamicViscosity{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static DynamicViscosity<T> FromCentipoise(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.CentipoiseToPascalSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-DynamicViscosity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IDynamicViscosityUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two DynamicViscosity values, returning the absolute difference as a non-negative DynamicViscosity.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static DynamicViscosity<T> operator -(DynamicViscosity<T> left, DynamicViscosity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static DynamicViscosity<T> operator -(DynamicViscosity<T> left, DynamicViscosity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Divides DynamicViscosity by Density to produce KinematicViscosity.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static KinematicViscosity<T> operator /(DynamicViscosity<T> left, Density<T> right) => Divide<KinematicViscosity<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static KinematicViscosity<T> operator /(DynamicViscosity<T> left, Density<T> right) => Divide<KinematicViscosity<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EMF.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EMF.g.cs
index ce1a047e..cf0135c7 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EMF.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EMF.g.cs
@@ -26,27 +26,34 @@ public partial record EMF<T> : PhysicalQuantity<EMF<T>, T>, IVector0<EMF<T>, T>
 	/// <returns>A new EMF instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static EMF<T> FromVolt(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new EMF from a value in Kilovolt.
 	/// </summary>
 	/// <param name="value">The value in Kilovolt.</param>
 	/// <returns>A new EMF instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static EMF<T> FromKilovolt(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricPotential unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricPotentialUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to VoltageMagnitude.</summary>
+
+	/// <summary>Implicit conversion to VoltageMagnitude.</summary>
 	public static implicit operator VoltageMagnitude<T>(EMF<T> value) => VoltageMagnitude<T>.Create(value.Value);
-/// <summary>Explicit conversion from VoltageMagnitude.</summary>
+
+	/// <summary>Explicit conversion from VoltageMagnitude.</summary>
 	public static explicit operator EMF<T>(VoltageMagnitude<T> value) => Create(value.Value);
-/// <summary>Creates a EMF from a VoltageMagnitude value.</summary>
+
+	/// <summary>Creates a EMF from a VoltageMagnitude value.</summary>
 	public static EMF<T> From(VoltageMagnitude<T> value) => Create(value.Value);
-/// <summary>Subtracts two EMF values, returning the absolute difference as a non-negative EMF.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static EMF<T> operator -(EMF<T> left, EMF<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two EMF values, returning the absolute difference as a non-negative EMF.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static EMF<T> operator -(EMF<T> left, EMF<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricConductivity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricConductivity.g.cs
index c0d72037..b42be543 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricConductivity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricConductivity.g.cs
@@ -25,17 +25,20 @@ public partial record ElectricConductivity<T> : PhysicalQuantity<ElectricConduct
 	/// <returns>A new <see cref="ElectricConductivity{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ElectricConductivity<T> FromSiemensPerMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricConductivity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricConductivityUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two ElectricConductivity values, returning the absolute difference as a non-negative ElectricConductivity.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ElectricConductivity<T> operator -(ElectricConductivity<T> left, ElectricConductivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ElectricConductivity<T> operator -(ElectricConductivity<T> left, ElectricConductivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricField1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricField1D.g.cs
index d061e47f..1a6fbc4f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricField1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricField1D.g.cs
@@ -24,21 +24,25 @@ public partial record ElectricField1D<T> : PhysicalQuantity<ElectricField1D<T>,
 	/// <param name="value">The value in VoltPerMeter.</param>
 	/// <returns>A new <see cref="ElectricField1D{T}"/> instance.</returns>
 	public static ElectricField1D<T> FromVoltPerMeter(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricField unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricFieldUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="ElectricFieldMagnitude{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public ElectricFieldMagnitude<T> Magnitude() => ElectricFieldMagnitude<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Multiplies ElectricField1D by Length to produce Voltage.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Voltage<T> operator *(ElectricField1D<T> left, Length<T> right) => Multiply<Voltage<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Voltage<T> operator *(ElectricField1D<T> left, Length<T> right) => Multiply<Voltage<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricFieldMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricFieldMagnitude.g.cs
index 6920c3ff..e4b43a93 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricFieldMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricFieldMagnitude.g.cs
@@ -25,25 +25,32 @@ public partial record ElectricFieldMagnitude<T> : PhysicalQuantity<ElectricField
 	/// <returns>A new <see cref="ElectricFieldMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ElectricFieldMagnitude<T> FromVoltPerMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricField unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricFieldUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two ElectricFieldMagnitude values, returning the absolute difference as a non-negative ElectricFieldMagnitude.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ElectricFieldMagnitude<T> operator -(ElectricFieldMagnitude<T> left, ElectricFieldMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ElectricFieldMagnitude<T> operator -(ElectricFieldMagnitude<T> left, ElectricFieldMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies ElectricFieldMagnitude by Length to produce VoltageMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static VoltageMagnitude<T> operator *(ElectricFieldMagnitude<T> left, Length<T> right) => Multiply<VoltageMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(ElectricFieldMagnitude<T> left, Length<T> right) => Multiply<VoltageMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies ElectricFieldMagnitude by Area to produce ElectricFlux.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ElectricFlux<T> operator *(ElectricFieldMagnitude<T> left, Area<T> right) => Multiply<ElectricFlux<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ElectricFlux<T> operator *(ElectricFieldMagnitude<T> left, Area<T> right) => Multiply<ElectricFlux<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricFlux.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricFlux.g.cs
index 39de8e87..5257d802 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricFlux.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricFlux.g.cs
@@ -25,25 +25,32 @@ public partial record ElectricFlux<T> : PhysicalQuantity<ElectricFlux<T>, T>, IV
 	/// <returns>A new <see cref="ElectricFlux{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ElectricFlux<T> FromVoltMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricFlux unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricFluxUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two ElectricFlux values, returning the absolute difference as a non-negative ElectricFlux.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ElectricFlux<T> operator -(ElectricFlux<T> left, ElectricFlux<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ElectricFlux<T> operator -(ElectricFlux<T> left, ElectricFlux<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Divides ElectricFlux by Area to produce ElectricFieldMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ElectricFieldMagnitude<T> operator /(ElectricFlux<T> left, Area<T> right) => Divide<ElectricFieldMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ElectricFieldMagnitude<T> operator /(ElectricFlux<T> left, Area<T> right) => Divide<ElectricFieldMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides ElectricFlux by ElectricFieldMagnitude to produce Area.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Area<T> operator /(ElectricFlux<T> left, ElectricFieldMagnitude<T> right) => Divide<Area<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator /(ElectricFlux<T> left, ElectricFieldMagnitude<T> right) => Divide<Area<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricPowerDensity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricPowerDensity.g.cs
index bc09ba4b..691f17b9 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricPowerDensity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricPowerDensity.g.cs
@@ -25,21 +25,26 @@ public partial record ElectricPowerDensity<T> : PhysicalQuantity<ElectricPowerDe
 	/// <returns>A new <see cref="ElectricPowerDensity{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ElectricPowerDensity<T> FromWattPerCubicMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricPowerDensity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricPowerDensityUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two ElectricPowerDensity values, returning the absolute difference as a non-negative ElectricPowerDensity.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ElectricPowerDensity<T> operator -(ElectricPowerDensity<T> left, ElectricPowerDensity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ElectricPowerDensity<T> operator -(ElectricPowerDensity<T> left, ElectricPowerDensity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies ElectricPowerDensity by Volume to produce Power.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Power<T> operator *(ElectricPowerDensity<T> left, Volume<T> right) => Multiply<Power<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(ElectricPowerDensity<T> left, Volume<T> right) => Multiply<Power<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Energy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Energy.g.cs
index d520619f..58982ab5 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Energy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Energy.g.cs
@@ -25,121 +25,156 @@ public partial record Energy<T> : PhysicalQuantity<Energy<T>, T>, IVector0<Energ
 	/// <returns>A new <see cref="Energy{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Energy<T> FromJoule(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Energy{T}"/> from a value in Kilojoule.
 	/// </summary>
 	/// <param name="value">The value in Kilojoule.</param>
 	/// <returns>A new <see cref="Energy{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Energy<T> FromKilojoule(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Energy{T}"/> from a value in ElectronVolt.
 	/// </summary>
 	/// <param name="value">The value in ElectronVolt.</param>
 	/// <returns>A new <see cref="Energy{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Energy<T> FromElectronVolt(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.ElectronVoltToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Energy{T}"/> from a value in Calorie.
 	/// </summary>
 	/// <param name="value">The value in Calorie.</param>
 	/// <returns>A new <see cref="Energy{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Energy<T> FromCalorie(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.CalorieToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Energy{T}"/> from a value in Kilocalorie.
 	/// </summary>
 	/// <param name="value">The value in Kilocalorie.</param>
 	/// <returns>A new <see cref="Energy{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Energy<T> FromKilocalorie(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilocalorieToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Energy{T}"/> from a value in KilowattHour.
 	/// </summary>
 	/// <param name="value">The value in KilowattHour.</param>
 	/// <returns>A new <see cref="Energy{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Energy<T> FromKilowattHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilowattHourToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Energy{T}"/> from a value in WattHour.
 	/// </summary>
 	/// <param name="value">The value in WattHour.</param>
 	/// <returns>A new <see cref="Energy{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Energy<T> FromWattHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.WattHourToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Energy{T}"/> from a value in Erg.
 	/// </summary>
 	/// <param name="value">The value in Erg.</param>
 	/// <returns>A new <see cref="Energy{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Energy<T> FromErg(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.ErgToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Energy{T}"/> from a value in Btu.
 	/// </summary>
 	/// <param name="value">The value in Btu.</param>
 	/// <returns>A new <see cref="Energy{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Energy<T> FromBtu(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.BtuToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Energy unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IEnergyUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Energy values, returning the absolute difference as a non-negative Energy.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Energy<T> operator -(Energy<T> left, Energy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator -(Energy<T> left, Energy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Divides Energy by Angle to produce TorqueMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static TorqueMagnitude<T> operator /(Energy<T> left, Angle<T> right) => Divide<TorqueMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static TorqueMagnitude<T> operator /(Energy<T> left, Angle<T> right) => Divide<TorqueMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides Energy by TorqueMagnitude to produce Angle.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Angle<T> operator /(Energy<T> left, TorqueMagnitude<T> right) => Divide<Angle<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Angle<T> operator /(Energy<T> left, TorqueMagnitude<T> right) => Divide<Angle<T>>(left, right);
+
+	/// <summary>
 	/// Divides Energy by Length to produce ForceMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ForceMagnitude<T> operator /(Energy<T> left, Length<T> right) => Divide<ForceMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator /(Energy<T> left, Length<T> right) => Divide<ForceMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides Energy by ForceMagnitude to produce Length.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Length<T> operator /(Energy<T> left, ForceMagnitude<T> right) => Divide<Length<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(Energy<T> left, ForceMagnitude<T> right) => Divide<Length<T>>(left, right);
+
+	/// <summary>
 	/// Divides Energy by Volume to produce Pressure.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Pressure<T> operator /(Energy<T> left, Volume<T> right) => Divide<Pressure<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator /(Energy<T> left, Volume<T> right) => Divide<Pressure<T>>(left, right);
+
+	/// <summary>
 	/// Divides Energy by Pressure to produce Volume.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Volume<T> operator /(Energy<T> left, Pressure<T> right) => Divide<Volume<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator /(Energy<T> left, Pressure<T> right) => Divide<Volume<T>>(left, right);
+
+	/// <summary>
 	/// Divides Energy by Duration to produce Power.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Power<T> operator /(Energy<T> left, Duration<T> right) => Divide<Power<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator /(Energy<T> left, Duration<T> right) => Divide<Power<T>>(left, right);
+
+	/// <summary>
 	/// Divides Energy by Power to produce Duration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Duration<T> operator /(Energy<T> left, Power<T> right) => Divide<Duration<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Energy<T> left, Power<T> right) => Divide<Duration<T>>(left, right);
+
+	/// <summary>
 	/// Divides Energy by Temperature to produce Entropy.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Entropy<T> operator /(Energy<T> left, Temperature<T> right) => Divide<Entropy<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Entropy<T> operator /(Energy<T> left, Temperature<T> right) => Divide<Entropy<T>>(left, right);
+
+	/// <summary>
 	/// Divides Energy by Entropy to produce Temperature.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Temperature<T> operator /(Energy<T> left, Entropy<T> right) => Divide<Temperature<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Temperature<T> operator /(Energy<T> left, Entropy<T> right) => Divide<Temperature<T>>(left, right);
+
+	/// <summary>
 	/// Divides Energy by AmountOfSubstance to produce MolarEnergy.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MolarEnergy<T> operator /(Energy<T> left, AmountOfSubstance<T> right) => Divide<MolarEnergy<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MolarEnergy<T> operator /(Energy<T> left, AmountOfSubstance<T> right) => Divide<MolarEnergy<T>>(left, right);
+
+	/// <summary>
 	/// Divides Energy by MolarEnergy to produce AmountOfSubstance.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AmountOfSubstance<T> operator /(Energy<T> left, MolarEnergy<T> right) => Divide<AmountOfSubstance<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator /(Energy<T> left, MolarEnergy<T> right) => Divide<AmountOfSubstance<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EnergyFluxDensity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EnergyFluxDensity.g.cs
index d4c1a28c..e9d490e2 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EnergyFluxDensity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EnergyFluxDensity.g.cs
@@ -26,20 +26,26 @@ public partial record EnergyFluxDensity<T> : PhysicalQuantity<EnergyFluxDensity<
 	/// <returns>A new EnergyFluxDensity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static EnergyFluxDensity<T> FromWattPerSquareMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Irradiance unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IIrradianceUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Irradiance.</summary>
+
+	/// <summary>Implicit conversion to Irradiance.</summary>
 	public static implicit operator Irradiance<T>(EnergyFluxDensity<T> value) => Irradiance<T>.Create(value.Value);
-/// <summary>Explicit conversion from Irradiance.</summary>
+
+	/// <summary>Explicit conversion from Irradiance.</summary>
 	public static explicit operator EnergyFluxDensity<T>(Irradiance<T> value) => Create(value.Value);
-/// <summary>Creates a EnergyFluxDensity from a Irradiance value.</summary>
+
+	/// <summary>Creates a EnergyFluxDensity from a Irradiance value.</summary>
 	public static EnergyFluxDensity<T> From(Irradiance<T> value) => Create(value.Value);
-/// <summary>Subtracts two EnergyFluxDensity values, returning the absolute difference as a non-negative EnergyFluxDensity.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static EnergyFluxDensity<T> operator -(EnergyFluxDensity<T> left, EnergyFluxDensity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two EnergyFluxDensity values, returning the absolute difference as a non-negative EnergyFluxDensity.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static EnergyFluxDensity<T> operator -(EnergyFluxDensity<T> left, EnergyFluxDensity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Entropy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Entropy.g.cs
index 3d375c6d..c8f4ee96 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Entropy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Entropy.g.cs
@@ -25,29 +25,38 @@ public partial record Entropy<T> : PhysicalQuantity<Entropy<T>, T>, IVector0<Ent
 	/// <returns>A new <see cref="Entropy{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Entropy<T> FromJoulePerKelvin(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Entropy unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IEntropyUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Entropy values, returning the absolute difference as a non-negative Entropy.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Entropy<T> operator -(Entropy<T> left, Entropy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Entropy<T> operator -(Entropy<T> left, Entropy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Entropy by Temperature to produce Energy.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Energy<T> operator *(Entropy<T> left, Temperature<T> right) => Multiply<Energy<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Entropy<T> left, Temperature<T> right) => Multiply<Energy<T>>(left, right);
+
+	/// <summary>
 	/// Divides Entropy by Mass to produce SpecificHeat.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SpecificHeat<T> operator /(Entropy<T> left, Mass<T> right) => Divide<SpecificHeat<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SpecificHeat<T> operator /(Entropy<T> left, Mass<T> right) => Divide<SpecificHeat<T>>(left, right);
+
+	/// <summary>
 	/// Divides Entropy by SpecificHeat to produce Mass.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Mass<T> operator /(Entropy<T> left, SpecificHeat<T> right) => Divide<Mass<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator /(Entropy<T> left, SpecificHeat<T> right) => Divide<Mass<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EnzymeActivity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EnzymeActivity.g.cs
index bfc95c86..dda5f1f5 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EnzymeActivity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EnzymeActivity.g.cs
@@ -26,27 +26,34 @@ public partial record EnzymeActivity<T> : PhysicalQuantity<EnzymeActivity<T>, T>
 	/// <returns>A new EnzymeActivity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static EnzymeActivity<T> FromKatal(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new EnzymeActivity from a value in EnzymeUnit.
 	/// </summary>
 	/// <param name="value">The value in EnzymeUnit.</param>
 	/// <returns>A new EnzymeActivity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static EnzymeActivity<T> FromEnzymeUnit(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.EnzymeUnitToKatals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-CatalyticActivity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ICatalyticActivityUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to CatalyticActivity.</summary>
+
+	/// <summary>Implicit conversion to CatalyticActivity.</summary>
 	public static implicit operator CatalyticActivity<T>(EnzymeActivity<T> value) => CatalyticActivity<T>.Create(value.Value);
-/// <summary>Explicit conversion from CatalyticActivity.</summary>
+
+	/// <summary>Explicit conversion from CatalyticActivity.</summary>
 	public static explicit operator EnzymeActivity<T>(CatalyticActivity<T> value) => Create(value.Value);
-/// <summary>Creates a EnzymeActivity from a CatalyticActivity value.</summary>
+
+	/// <summary>Creates a EnzymeActivity from a CatalyticActivity value.</summary>
 	public static EnzymeActivity<T> From(CatalyticActivity<T> value) => Create(value.Value);
-/// <summary>Subtracts two EnzymeActivity values, returning the absolute difference as a non-negative EnzymeActivity.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static EnzymeActivity<T> operator -(EnzymeActivity<T> left, EnzymeActivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two EnzymeActivity values, returning the absolute difference as a non-negative EnzymeActivity.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static EnzymeActivity<T> operator -(EnzymeActivity<T> left, EnzymeActivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EquivalentDose.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EquivalentDose.g.cs
index 4996d45a..4c24ba26 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EquivalentDose.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EquivalentDose.g.cs
@@ -25,24 +25,28 @@ public partial record EquivalentDose<T> : PhysicalQuantity<EquivalentDose<T>, T>
 	/// <returns>A new <see cref="EquivalentDose{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static EquivalentDose<T> FromSievert(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="EquivalentDose{T}"/> from a value in Rem.
 	/// </summary>
 	/// <param name="value">The value in Rem.</param>
 	/// <returns>A new <see cref="EquivalentDose{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static EquivalentDose<T> FromRem(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.RemToSieverts)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-EquivalentDose unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IEquivalentDoseUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two EquivalentDose values, returning the absolute difference as a non-negative EquivalentDose.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static EquivalentDose<T> operator -(EquivalentDose<T> left, EquivalentDose<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static EquivalentDose<T> operator -(EquivalentDose<T> left, EquivalentDose<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Exposure.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Exposure.g.cs
index a37bfcc1..382551f0 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Exposure.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Exposure.g.cs
@@ -25,24 +25,28 @@ public partial record Exposure<T> : PhysicalQuantity<Exposure<T>, T>, IVector0<E
 	/// <returns>A new <see cref="Exposure{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Exposure<T> FromCoulombPerKilogram(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Exposure{T}"/> from a value in Roentgen.
 	/// </summary>
 	/// <param name="value">The value in Roentgen.</param>
 	/// <returns>A new <see cref="Exposure{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Exposure<T> FromRoentgen(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.RoentgenToCoulombsPerKilogram)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Exposure unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IExposureUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Exposure values, returning the absolute difference as a non-negative Exposure.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Exposure<T> operator -(Exposure<T> left, Exposure<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Exposure<T> operator -(Exposure<T> left, Exposure<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/FieldOfView.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/FieldOfView.g.cs
index cd7b30ae..95d79e51 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/FieldOfView.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/FieldOfView.g.cs
@@ -26,48 +26,58 @@ public partial record FieldOfView<T> : PhysicalQuantity<FieldOfView<T>, T>, IVec
 	/// <returns>A new FieldOfView instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static FieldOfView<T> FromRadian(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new FieldOfView from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new FieldOfView instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static FieldOfView<T> FromDegree(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new FieldOfView from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new FieldOfView instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static FieldOfView<T> FromGradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new FieldOfView from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new FieldOfView instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static FieldOfView<T> FromRevolution(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new FieldOfView from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new FieldOfView instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static FieldOfView<T> FromMilliradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AngularDisplacement unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAngularDisplacementUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Angle.</summary>
+
+	/// <summary>Implicit conversion to Angle.</summary>
 	public static implicit operator Angle<T>(FieldOfView<T> value) => Angle<T>.Create(value.Value);
-/// <summary>Explicit conversion from Angle.</summary>
+
+	/// <summary>Explicit conversion from Angle.</summary>
 	public static explicit operator FieldOfView<T>(Angle<T> value) => Create(value.Value);
-/// <summary>Creates a FieldOfView from a Angle value.</summary>
+
+	/// <summary>Creates a FieldOfView from a Angle value.</summary>
 	public static FieldOfView<T> From(Angle<T> value) => Create(value.Value);
-/// <summary>Subtracts two FieldOfView values, returning the absolute difference as a non-negative FieldOfView.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static FieldOfView<T> operator -(FieldOfView<T> left, FieldOfView<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two FieldOfView values, returning the absolute difference as a non-negative FieldOfView.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static FieldOfView<T> operator -(FieldOfView<T> left, FieldOfView<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/FlowSpeed.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/FlowSpeed.g.cs
index e975230d..a1b77b33 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/FlowSpeed.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/FlowSpeed.g.cs
@@ -26,48 +26,58 @@ public partial record FlowSpeed<T> : PhysicalQuantity<FlowSpeed<T>, T>, IVector0
 	/// <returns>A new FlowSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static FlowSpeed<T> FromMeterPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new FlowSpeed from a value in KilometerPerHour.
 	/// </summary>
 	/// <param name="value">The value in KilometerPerHour.</param>
 	/// <returns>A new FlowSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static FlowSpeed<T> FromKilometerPerHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilometerPerHourToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new FlowSpeed from a value in MilePerHour.
 	/// </summary>
 	/// <param name="value">The value in MilePerHour.</param>
 	/// <returns>A new FlowSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static FlowSpeed<T> FromMilePerHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MilePerHourToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new FlowSpeed from a value in FootPerSecond.
 	/// </summary>
 	/// <param name="value">The value in FootPerSecond.</param>
 	/// <returns>A new FlowSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static FlowSpeed<T> FromFootPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FootPerSecondToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new FlowSpeed from a value in Knot.
 	/// </summary>
 	/// <param name="value">The value in Knot.</param>
 	/// <returns>A new FlowSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static FlowSpeed<T> FromKnot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KnotToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Velocity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IVelocityUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Speed.</summary>
+
+	/// <summary>Implicit conversion to Speed.</summary>
 	public static implicit operator Speed<T>(FlowSpeed<T> value) => Speed<T>.Create(value.Value);
-/// <summary>Explicit conversion from Speed.</summary>
+
+	/// <summary>Explicit conversion from Speed.</summary>
 	public static explicit operator FlowSpeed<T>(Speed<T> value) => Create(value.Value);
-/// <summary>Creates a FlowSpeed from a Speed value.</summary>
+
+	/// <summary>Creates a FlowSpeed from a Speed value.</summary>
 	public static FlowSpeed<T> From(Speed<T> value) => Create(value.Value);
-/// <summary>Subtracts two FlowSpeed values, returning the absolute difference as a non-negative FlowSpeed.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static FlowSpeed<T> operator -(FlowSpeed<T> left, FlowSpeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two FlowSpeed values, returning the absolute difference as a non-negative FlowSpeed.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static FlowSpeed<T> operator -(FlowSpeed<T> left, FlowSpeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Force1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Force1D.g.cs
index 97422b37..fa1a261d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Force1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Force1D.g.cs
@@ -24,39 +24,46 @@ public partial record Force1D<T> : PhysicalQuantity<Force1D<T>, T>, IVector1<For
 	/// <param name="value">The value in Newton.</param>
 	/// <returns>A new <see cref="Force1D{T}"/> instance.</returns>
 	public static Force1D<T> FromNewton(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Force1D{T}"/> from a value in Kilonewton.
 	/// </summary>
 	/// <param name="value">The value in Kilonewton.</param>
 	/// <returns>A new <see cref="Force1D{T}"/> instance.</returns>
 	public static Force1D<T> FromKilonewton(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Kilo)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Force1D{T}"/> from a value in Dyne.
 	/// </summary>
 	/// <param name="value">The value in Dyne.</param>
 	/// <returns>A new <see cref="Force1D{T}"/> instance.</returns>
 	public static Force1D<T> FromDyne(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.DyneToNewtons)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Force1D{T}"/> from a value in PoundForce.
 	/// </summary>
 	/// <param name="value">The value in PoundForce.</param>
 	/// <returns>A new <see cref="Force1D{T}"/> instance.</returns>
 	public static Force1D<T> FromPoundForce(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.PoundForceToNewtons)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Force unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IForceUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="ForceMagnitude{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public ForceMagnitude<T> Magnitude() => ForceMagnitude<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Multiplies Force1D by Duration to produce Momentum1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Momentum1D<T> operator *(Force1D<T> left, Duration<T> right) => Multiply<Momentum1D<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum1D<T> operator *(Force1D<T> left, Duration<T> right) => Multiply<Momentum1D<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ForceMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ForceMagnitude.g.cs
index ca5d91dd..7214a84c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ForceMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ForceMagnitude.g.cs
@@ -25,70 +25,92 @@ public partial record ForceMagnitude<T> : PhysicalQuantity<ForceMagnitude<T>, T>
 	/// <returns>A new <see cref="ForceMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ForceMagnitude<T> FromNewton(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="ForceMagnitude{T}"/> from a value in Kilonewton.
 	/// </summary>
 	/// <param name="value">The value in Kilonewton.</param>
 	/// <returns>A new <see cref="ForceMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ForceMagnitude<T> FromKilonewton(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="ForceMagnitude{T}"/> from a value in Dyne.
 	/// </summary>
 	/// <param name="value">The value in Dyne.</param>
 	/// <returns>A new <see cref="ForceMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ForceMagnitude<T> FromDyne(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DyneToNewtons)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="ForceMagnitude{T}"/> from a value in PoundForce.
 	/// </summary>
 	/// <param name="value">The value in PoundForce.</param>
 	/// <returns>A new <see cref="ForceMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ForceMagnitude<T> FromPoundForce(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PoundForceToNewtons)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Force unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IForceUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two ForceMagnitude values, returning the absolute difference as a non-negative ForceMagnitude.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ForceMagnitude<T> operator -(ForceMagnitude<T> left, ForceMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator -(ForceMagnitude<T> left, ForceMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Divides ForceMagnitude by AccelerationMagnitude to produce Mass.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Mass<T> operator /(ForceMagnitude<T> left, AccelerationMagnitude<T> right) => Divide<Mass<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator /(ForceMagnitude<T> left, AccelerationMagnitude<T> right) => Divide<Mass<T>>(left, right);
+
+	/// <summary>
 	/// Divides ForceMagnitude by Mass to produce AccelerationMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AccelerationMagnitude<T> operator /(ForceMagnitude<T> left, Mass<T> right) => Divide<AccelerationMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator /(ForceMagnitude<T> left, Mass<T> right) => Divide<AccelerationMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies ForceMagnitude by Length to produce Energy.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Energy<T> operator *(ForceMagnitude<T> left, Length<T> right) => Multiply<Energy<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(ForceMagnitude<T> left, Length<T> right) => Multiply<Energy<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies ForceMagnitude by Duration to produce MomentumMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MomentumMagnitude<T> operator *(ForceMagnitude<T> left, Duration<T> right) => Multiply<MomentumMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(ForceMagnitude<T> left, Duration<T> right) => Multiply<MomentumMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies ForceMagnitude by Speed to produce Power.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Power<T> operator *(ForceMagnitude<T> left, Speed<T> right) => Multiply<Power<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(ForceMagnitude<T> left, Speed<T> right) => Multiply<Power<T>>(left, right);
+
+	/// <summary>
 	/// Divides ForceMagnitude by Area to produce Pressure.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Pressure<T> operator /(ForceMagnitude<T> left, Area<T> right) => Divide<Pressure<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator /(ForceMagnitude<T> left, Area<T> right) => Divide<Pressure<T>>(left, right);
+
+	/// <summary>
 	/// Divides ForceMagnitude by Length to produce SurfaceTension.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SurfaceTension<T> operator /(ForceMagnitude<T> left, Length<T> right) => Divide<SurfaceTension<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SurfaceTension<T> operator /(ForceMagnitude<T> left, Length<T> right) => Divide<SurfaceTension<T>>(left, right);
+
+	/// <summary>
 	/// Divides ForceMagnitude by SurfaceTension to produce Length.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Length<T> operator /(ForceMagnitude<T> left, SurfaceTension<T> right) => Divide<Length<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(ForceMagnitude<T> left, SurfaceTension<T> right) => Divide<Length<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Frequency.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Frequency.g.cs
index 2bf89c0d..4129b5b9 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Frequency.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Frequency.g.cs
@@ -25,39 +25,48 @@ public partial record Frequency<T> : PhysicalQuantity<Frequency<T>, T>, IVector0
 	/// <returns>A new <see cref="Frequency{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Frequency<T> FromHertz(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Frequency{T}"/> from a value in Kilohertz.
 	/// </summary>
 	/// <param name="value">The value in Kilohertz.</param>
 	/// <returns>A new <see cref="Frequency{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Frequency<T> FromKilohertz(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Frequency{T}"/> from a value in Megahertz.
 	/// </summary>
 	/// <param name="value">The value in Megahertz.</param>
 	/// <returns>A new <see cref="Frequency{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Frequency<T> FromMegahertz(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Mega)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Frequency unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IFrequencyUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Frequency values, returning the absolute difference as a non-negative Frequency.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Frequency<T> operator -(Frequency<T> left, Frequency<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator -(Frequency<T> left, Frequency<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Frequency by Duration to produce Ratio.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Ratio<T> operator *(Frequency<T> left, Duration<T> right) => Multiply<Ratio<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(Frequency<T> left, Duration<T> right) => Multiply<Ratio<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Frequency by Length to produce Speed.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Speed<T> operator *(Frequency<T> left, Length<T> right) => Multiply<Speed<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(Frequency<T> left, Length<T> right) => Multiply<Speed<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Friction.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Friction.g.cs
index 6fcabcd5..a56b7911 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Friction.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Friction.g.cs
@@ -26,41 +26,50 @@ public partial record Friction<T> : PhysicalQuantity<Friction<T>, T>, IVector0<F
 	/// <returns>A new Friction instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Friction<T> FromNewton(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Friction from a value in Kilonewton.
 	/// </summary>
 	/// <param name="value">The value in Kilonewton.</param>
 	/// <returns>A new Friction instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Friction<T> FromKilonewton(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Friction from a value in Dyne.
 	/// </summary>
 	/// <param name="value">The value in Dyne.</param>
 	/// <returns>A new Friction instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Friction<T> FromDyne(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DyneToNewtons)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Friction from a value in PoundForce.
 	/// </summary>
 	/// <param name="value">The value in PoundForce.</param>
 	/// <returns>A new Friction instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Friction<T> FromPoundForce(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PoundForceToNewtons)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Force unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IForceUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to ForceMagnitude.</summary>
+
+	/// <summary>Implicit conversion to ForceMagnitude.</summary>
 	public static implicit operator ForceMagnitude<T>(Friction<T> value) => ForceMagnitude<T>.Create(value.Value);
-/// <summary>Explicit conversion from ForceMagnitude.</summary>
+
+	/// <summary>Explicit conversion from ForceMagnitude.</summary>
 	public static explicit operator Friction<T>(ForceMagnitude<T> value) => Create(value.Value);
-/// <summary>Creates a Friction from a ForceMagnitude value.</summary>
+
+	/// <summary>Creates a Friction from a ForceMagnitude value.</summary>
 	public static Friction<T> From(ForceMagnitude<T> value) => Create(value.Value);
-/// <summary>Subtracts two Friction values, returning the absolute difference as a non-negative Friction.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Friction<T> operator -(Friction<T> left, Friction<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Friction values, returning the absolute difference as a non-negative Friction.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Friction<T> operator -(Friction<T> left, Friction<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Gain.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Gain.g.cs
index 223b0ad8..330b6319 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Gain.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Gain.g.cs
@@ -26,83 +26,98 @@ public partial record Gain<T> : PhysicalQuantity<Gain<T>, T>, IVector0<Gain<T>,
 	/// <returns>A new Gain instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Gain<T> FromDimensionless(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Gain from a value in Radian.
 	/// </summary>
 	/// <param name="value">The value in Radian.</param>
 	/// <returns>A new Gain instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Gain<T> FromRadian(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Gain from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new Gain instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Gain<T> FromDegree(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Gain from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new Gain instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Gain<T> FromGradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Gain from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new Gain instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Gain<T> FromRevolution(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Gain from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new Gain instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Gain<T> FromMilliradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Gain from a value in Percent.
 	/// </summary>
 	/// <param name="value">The value in Percent.</param>
 	/// <returns>A new Gain instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Gain<T> FromPercent(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Gain from a value in PartPerMillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerMillion.</param>
 	/// <returns>A new Gain instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Gain<T> FromPartPerMillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerMillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Gain from a value in PartPerBillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerBillion.</param>
 	/// <returns>A new Gain instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Gain<T> FromPartPerBillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerBillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Gain from a value in PercentByWeight.
 	/// </summary>
 	/// <param name="value">The value in PercentByWeight.</param>
 	/// <returns>A new Gain instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Gain<T> FromPercentByWeight(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentByWeightToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Dimensionless unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IDimensionlessUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Ratio.</summary>
+
+	/// <summary>Implicit conversion to Ratio.</summary>
 	public static implicit operator Ratio<T>(Gain<T> value) => Ratio<T>.Create(value.Value);
-/// <summary>Explicit conversion from Ratio.</summary>
+
+	/// <summary>Explicit conversion from Ratio.</summary>
 	public static explicit operator Gain<T>(Ratio<T> value) => Create(value.Value);
-/// <summary>Creates a Gain from a Ratio value.</summary>
+
+	/// <summary>Creates a Gain from a Ratio value.</summary>
 	public static Gain<T> From(Ratio<T> value) => Create(value.Value);
-/// <summary>Subtracts two Gain values, returning the absolute difference as a non-negative Gain.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Gain<T> operator -(Gain<T> left, Gain<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Gain values, returning the absolute difference as a non-negative Gain.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Gain<T> operator -(Gain<T> left, Gain<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GaugePressure.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GaugePressure.g.cs
index ca277403..fb196ff8 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GaugePressure.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GaugePressure.g.cs
@@ -26,55 +26,66 @@ public partial record GaugePressure<T> : PhysicalQuantity<GaugePressure<T>, T>,
 	/// <returns>A new GaugePressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GaugePressure<T> FromPascal(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new GaugePressure from a value in Kilopascal.
 	/// </summary>
 	/// <param name="value">The value in Kilopascal.</param>
 	/// <returns>A new GaugePressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GaugePressure<T> FromKilopascal(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new GaugePressure from a value in Bar.
 	/// </summary>
 	/// <param name="value">The value in Bar.</param>
 	/// <returns>A new GaugePressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GaugePressure<T> FromBar(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.BarToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new GaugePressure from a value in Atmosphere.
 	/// </summary>
 	/// <param name="value">The value in Atmosphere.</param>
 	/// <returns>A new GaugePressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GaugePressure<T> FromAtmosphere(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AtmosphereToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new GaugePressure from a value in Psi.
 	/// </summary>
 	/// <param name="value">The value in Psi.</param>
 	/// <returns>A new GaugePressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GaugePressure<T> FromPsi(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PsiToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new GaugePressure from a value in Torr.
 	/// </summary>
 	/// <param name="value">The value in Torr.</param>
 	/// <returns>A new GaugePressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GaugePressure<T> FromTorr(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.TorrToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Pressure unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IPressureUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Pressure.</summary>
+
+	/// <summary>Implicit conversion to Pressure.</summary>
 	public static implicit operator Pressure<T>(GaugePressure<T> value) => Pressure<T>.Create(value.Value);
-/// <summary>Explicit conversion from Pressure.</summary>
+
+	/// <summary>Explicit conversion from Pressure.</summary>
 	public static explicit operator GaugePressure<T>(Pressure<T> value) => Create(value.Value);
-/// <summary>Creates a GaugePressure from a Pressure value.</summary>
+
+	/// <summary>Creates a GaugePressure from a Pressure value.</summary>
 	public static GaugePressure<T> From(Pressure<T> value) => Create(value.Value);
-/// <summary>Subtracts two GaugePressure values, returning the absolute difference as a non-negative GaugePressure.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static GaugePressure<T> operator -(GaugePressure<T> left, GaugePressure<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two GaugePressure values, returning the absolute difference as a non-negative GaugePressure.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GaugePressure<T> operator -(GaugePressure<T> left, GaugePressure<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalAcceleration.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalAcceleration.g.cs
index 9010ef26..a07969f5 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalAcceleration.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalAcceleration.g.cs
@@ -26,27 +26,34 @@ public partial record GravitationalAcceleration<T> : PhysicalQuantity<Gravitatio
 	/// <returns>A new GravitationalAcceleration instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GravitationalAcceleration<T> FromMeterPerSecondSquared(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new GravitationalAcceleration from a value in StandardGravity.
 	/// </summary>
 	/// <param name="value">The value in StandardGravity.</param>
 	/// <returns>A new GravitationalAcceleration instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GravitationalAcceleration<T> FromStandardGravity(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.StandardGravityToMeterPerSecondSquared)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Acceleration unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAccelerationUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to AccelerationMagnitude.</summary>
+
+	/// <summary>Implicit conversion to AccelerationMagnitude.</summary>
 	public static implicit operator AccelerationMagnitude<T>(GravitationalAcceleration<T> value) => AccelerationMagnitude<T>.Create(value.Value);
-/// <summary>Explicit conversion from AccelerationMagnitude.</summary>
+
+	/// <summary>Explicit conversion from AccelerationMagnitude.</summary>
 	public static explicit operator GravitationalAcceleration<T>(AccelerationMagnitude<T> value) => Create(value.Value);
-/// <summary>Creates a GravitationalAcceleration from a AccelerationMagnitude value.</summary>
+
+	/// <summary>Creates a GravitationalAcceleration from a AccelerationMagnitude value.</summary>
 	public static GravitationalAcceleration<T> From(AccelerationMagnitude<T> value) => Create(value.Value);
-/// <summary>Subtracts two GravitationalAcceleration values, returning the absolute difference as a non-negative GravitationalAcceleration.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static GravitationalAcceleration<T> operator -(GravitationalAcceleration<T> left, GravitationalAcceleration<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two GravitationalAcceleration values, returning the absolute difference as a non-negative GravitationalAcceleration.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GravitationalAcceleration<T> operator -(GravitationalAcceleration<T> left, GravitationalAcceleration<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GroundSpeed.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GroundSpeed.g.cs
index bec3a3ad..7dbb5613 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GroundSpeed.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GroundSpeed.g.cs
@@ -26,48 +26,58 @@ public partial record GroundSpeed<T> : PhysicalQuantity<GroundSpeed<T>, T>, IVec
 	/// <returns>A new GroundSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GroundSpeed<T> FromMeterPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new GroundSpeed from a value in KilometerPerHour.
 	/// </summary>
 	/// <param name="value">The value in KilometerPerHour.</param>
 	/// <returns>A new GroundSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GroundSpeed<T> FromKilometerPerHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilometerPerHourToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new GroundSpeed from a value in MilePerHour.
 	/// </summary>
 	/// <param name="value">The value in MilePerHour.</param>
 	/// <returns>A new GroundSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GroundSpeed<T> FromMilePerHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MilePerHourToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new GroundSpeed from a value in FootPerSecond.
 	/// </summary>
 	/// <param name="value">The value in FootPerSecond.</param>
 	/// <returns>A new GroundSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GroundSpeed<T> FromFootPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FootPerSecondToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new GroundSpeed from a value in Knot.
 	/// </summary>
 	/// <param name="value">The value in Knot.</param>
 	/// <returns>A new GroundSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GroundSpeed<T> FromKnot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KnotToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Velocity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IVelocityUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Speed.</summary>
+
+	/// <summary>Implicit conversion to Speed.</summary>
 	public static implicit operator Speed<T>(GroundSpeed<T> value) => Speed<T>.Create(value.Value);
-/// <summary>Explicit conversion from Speed.</summary>
+
+	/// <summary>Explicit conversion from Speed.</summary>
 	public static explicit operator GroundSpeed<T>(Speed<T> value) => Create(value.Value);
-/// <summary>Creates a GroundSpeed from a Speed value.</summary>
+
+	/// <summary>Creates a GroundSpeed from a Speed value.</summary>
 	public static GroundSpeed<T> From(Speed<T> value) => Create(value.Value);
-/// <summary>Subtracts two GroundSpeed values, returning the absolute difference as a non-negative GroundSpeed.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static GroundSpeed<T> operator -(GroundSpeed<T> left, GroundSpeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two GroundSpeed values, returning the absolute difference as a non-negative GroundSpeed.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GroundSpeed<T> operator -(GroundSpeed<T> left, GroundSpeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GroupVelocity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GroupVelocity.g.cs
index 5c5ea679..3a281582 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GroupVelocity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GroupVelocity.g.cs
@@ -26,48 +26,58 @@ public partial record GroupVelocity<T> : PhysicalQuantity<GroupVelocity<T>, T>,
 	/// <returns>A new GroupVelocity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GroupVelocity<T> FromMeterPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new GroupVelocity from a value in KilometerPerHour.
 	/// </summary>
 	/// <param name="value">The value in KilometerPerHour.</param>
 	/// <returns>A new GroupVelocity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GroupVelocity<T> FromKilometerPerHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilometerPerHourToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new GroupVelocity from a value in MilePerHour.
 	/// </summary>
 	/// <param name="value">The value in MilePerHour.</param>
 	/// <returns>A new GroupVelocity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GroupVelocity<T> FromMilePerHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MilePerHourToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new GroupVelocity from a value in FootPerSecond.
 	/// </summary>
 	/// <param name="value">The value in FootPerSecond.</param>
 	/// <returns>A new GroupVelocity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GroupVelocity<T> FromFootPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FootPerSecondToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new GroupVelocity from a value in Knot.
 	/// </summary>
 	/// <param name="value">The value in Knot.</param>
 	/// <returns>A new GroupVelocity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static GroupVelocity<T> FromKnot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KnotToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Velocity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IVelocityUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Speed.</summary>
+
+	/// <summary>Implicit conversion to Speed.</summary>
 	public static implicit operator Speed<T>(GroupVelocity<T> value) => Speed<T>.Create(value.Value);
-/// <summary>Explicit conversion from Speed.</summary>
+
+	/// <summary>Explicit conversion from Speed.</summary>
 	public static explicit operator GroupVelocity<T>(Speed<T> value) => Create(value.Value);
-/// <summary>Creates a GroupVelocity from a Speed value.</summary>
+
+	/// <summary>Creates a GroupVelocity from a Speed value.</summary>
 	public static GroupVelocity<T> From(Speed<T> value) => Create(value.Value);
-/// <summary>Subtracts two GroupVelocity values, returning the absolute difference as a non-negative GroupVelocity.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static GroupVelocity<T> operator -(GroupVelocity<T> left, GroupVelocity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two GroupVelocity values, returning the absolute difference as a non-negative GroupVelocity.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GroupVelocity<T> operator -(GroupVelocity<T> left, GroupVelocity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HalfLife.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HalfLife.g.cs
index 6a83c773..c01cd5bb 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HalfLife.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HalfLife.g.cs
@@ -26,76 +26,90 @@ public partial record HalfLife<T> : PhysicalQuantity<HalfLife<T>, T>, IVector0<H
 	/// <returns>A new HalfLife instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static HalfLife<T> FromSecond(T value) => Create(Vector0Guards.EnsurePositive(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new HalfLife from a value in Millisecond.
 	/// </summary>
 	/// <param name="value">The value in Millisecond.</param>
 	/// <returns>A new HalfLife instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static HalfLife<T> FromMillisecond(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new HalfLife from a value in Microsecond.
 	/// </summary>
 	/// <param name="value">The value in Microsecond.</param>
 	/// <returns>A new HalfLife instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static HalfLife<T> FromMicrosecond(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new HalfLife from a value in Minute.
 	/// </summary>
 	/// <param name="value">The value in Minute.</param>
 	/// <returns>A new HalfLife instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static HalfLife<T> FromMinute(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.MinuteToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new HalfLife from a value in Hour.
 	/// </summary>
 	/// <param name="value">The value in Hour.</param>
 	/// <returns>A new HalfLife instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static HalfLife<T> FromHour(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.HourToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new HalfLife from a value in Day.
 	/// </summary>
 	/// <param name="value">The value in Day.</param>
 	/// <returns>A new HalfLife instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static HalfLife<T> FromDay(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.DayToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new HalfLife from a value in Year.
 	/// </summary>
 	/// <param name="value">The value in Year.</param>
 	/// <returns>A new HalfLife instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static HalfLife<T> FromYear(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.YearToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new HalfLife from a value in Week.
 	/// </summary>
 	/// <param name="value">The value in Week.</param>
 	/// <returns>A new HalfLife instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static HalfLife<T> FromWeek(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.WeekToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new HalfLife from a value in Nanosecond.
 	/// </summary>
 	/// <param name="value">The value in Nanosecond.</param>
 	/// <returns>A new HalfLife instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static HalfLife<T> FromNanosecond(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Time unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ITimeUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Duration.</summary>
+
+	/// <summary>Implicit conversion to Duration.</summary>
 	public static implicit operator Duration<T>(HalfLife<T> value) => Duration<T>.Create(value.Value);
-/// <summary>Explicit conversion from Duration.</summary>
+
+	/// <summary>Explicit conversion from Duration.</summary>
 	public static explicit operator HalfLife<T>(Duration<T> value) => Create(value.Value);
-/// <summary>Creates a HalfLife from a Duration value.</summary>
+
+	/// <summary>Creates a HalfLife from a Duration value.</summary>
 	public static HalfLife<T> From(Duration<T> value) => Create(value.Value);
-/// <summary>Subtracts two HalfLife values, returning the absolute difference as a non-negative HalfLife.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static HalfLife<T> operator -(HalfLife<T> left, HalfLife<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two HalfLife values, returning the absolute difference as a non-negative HalfLife.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static HalfLife<T> operator -(HalfLife<T> left, HalfLife<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Heading.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Heading.g.cs
index 1e692c89..794535fb 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Heading.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Heading.g.cs
@@ -25,42 +25,50 @@ public partial record Heading<T> : PhysicalQuantity<Heading<T>, T>, IVector1<Hea
 	/// <param name="value">The value in Radian.</param>
 	/// <returns>A new Heading instance.</returns>
 	public static Heading<T> FromRadian(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Heading from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new Heading instance.</returns>
 	public static Heading<T> FromDegree(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Heading from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new Heading instance.</returns>
 	public static Heading<T> FromGradian(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Heading from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new Heading instance.</returns>
 	public static Heading<T> FromRevolution(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Heading from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new Heading instance.</returns>
 	public static Heading<T> FromMilliradian(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Milli)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AngularDisplacement unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAngularDisplacementUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to SignedAngle.</summary>
+
+	/// <summary>Implicit conversion to SignedAngle.</summary>
 	public static implicit operator SignedAngle<T>(Heading<T> value) => SignedAngle<T>.Create(value.Value);
-/// <summary>Explicit conversion from SignedAngle.</summary>
+
+	/// <summary>Explicit conversion from SignedAngle.</summary>
 	public static explicit operator Heading<T>(SignedAngle<T> value) => Create(value.Value);
-/// <summary>Creates a Heading from a SignedAngle value.</summary>
+
+	/// <summary>Creates a Heading from a SignedAngle value.</summary>
 	public static Heading<T> From(SignedAngle<T> value) => Create(value.Value);
-};
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Heat.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Heat.g.cs
index 38a0f488..33333d18 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Heat.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Heat.g.cs
@@ -26,76 +26,90 @@ public partial record Heat<T> : PhysicalQuantity<Heat<T>, T>, IVector0<Heat<T>,
 	/// <returns>A new Heat instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Heat<T> FromJoule(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Heat from a value in Kilojoule.
 	/// </summary>
 	/// <param name="value">The value in Kilojoule.</param>
 	/// <returns>A new Heat instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Heat<T> FromKilojoule(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Heat from a value in ElectronVolt.
 	/// </summary>
 	/// <param name="value">The value in ElectronVolt.</param>
 	/// <returns>A new Heat instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Heat<T> FromElectronVolt(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.ElectronVoltToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Heat from a value in Calorie.
 	/// </summary>
 	/// <param name="value">The value in Calorie.</param>
 	/// <returns>A new Heat instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Heat<T> FromCalorie(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.CalorieToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Heat from a value in Kilocalorie.
 	/// </summary>
 	/// <param name="value">The value in Kilocalorie.</param>
 	/// <returns>A new Heat instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Heat<T> FromKilocalorie(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilocalorieToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Heat from a value in KilowattHour.
 	/// </summary>
 	/// <param name="value">The value in KilowattHour.</param>
 	/// <returns>A new Heat instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Heat<T> FromKilowattHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilowattHourToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Heat from a value in WattHour.
 	/// </summary>
 	/// <param name="value">The value in WattHour.</param>
 	/// <returns>A new Heat instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Heat<T> FromWattHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.WattHourToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Heat from a value in Erg.
 	/// </summary>
 	/// <param name="value">The value in Erg.</param>
 	/// <returns>A new Heat instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Heat<T> FromErg(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.ErgToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Heat from a value in Btu.
 	/// </summary>
 	/// <param name="value">The value in Btu.</param>
 	/// <returns>A new Heat instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Heat<T> FromBtu(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.BtuToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Energy unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IEnergyUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Energy.</summary>
+
+	/// <summary>Implicit conversion to Energy.</summary>
 	public static implicit operator Energy<T>(Heat<T> value) => Energy<T>.Create(value.Value);
-/// <summary>Explicit conversion from Energy.</summary>
+
+	/// <summary>Explicit conversion from Energy.</summary>
 	public static explicit operator Heat<T>(Energy<T> value) => Create(value.Value);
-/// <summary>Creates a Heat from a Energy value.</summary>
+
+	/// <summary>Creates a Heat from a Energy value.</summary>
 	public static Heat<T> From(Energy<T> value) => Create(value.Value);
-/// <summary>Subtracts two Heat values, returning the absolute difference as a non-negative Heat.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Heat<T> operator -(Heat<T> left, Heat<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Heat values, returning the absolute difference as a non-negative Heat.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Heat<T> operator -(Heat<T> left, Heat<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatCapacity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatCapacity.g.cs
index ee76c2e9..24b3e03d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatCapacity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatCapacity.g.cs
@@ -26,20 +26,26 @@ public partial record HeatCapacity<T> : PhysicalQuantity<HeatCapacity<T>, T>, IV
 	/// <returns>A new HeatCapacity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static HeatCapacity<T> FromJoulePerKelvin(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Entropy unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IEntropyUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Entropy.</summary>
+
+	/// <summary>Implicit conversion to Entropy.</summary>
 	public static implicit operator Entropy<T>(HeatCapacity<T> value) => Entropy<T>.Create(value.Value);
-/// <summary>Explicit conversion from Entropy.</summary>
+
+	/// <summary>Explicit conversion from Entropy.</summary>
 	public static explicit operator HeatCapacity<T>(Entropy<T> value) => Create(value.Value);
-/// <summary>Creates a HeatCapacity from a Entropy value.</summary>
+
+	/// <summary>Creates a HeatCapacity from a Entropy value.</summary>
 	public static HeatCapacity<T> From(Entropy<T> value) => Create(value.Value);
-/// <summary>Subtracts two HeatCapacity values, returning the absolute difference as a non-negative HeatCapacity.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static HeatCapacity<T> operator -(HeatCapacity<T> left, HeatCapacity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two HeatCapacity values, returning the absolute difference as a non-negative HeatCapacity.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static HeatCapacity<T> operator -(HeatCapacity<T> left, HeatCapacity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatFlowRate.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatFlowRate.g.cs
index 9cca4ecd..237cd993 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatFlowRate.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatFlowRate.g.cs
@@ -26,41 +26,50 @@ public partial record HeatFlowRate<T> : PhysicalQuantity<HeatFlowRate<T>, T>, IV
 	/// <returns>A new HeatFlowRate instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static HeatFlowRate<T> FromWatt(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new HeatFlowRate from a value in Kilowatt.
 	/// </summary>
 	/// <param name="value">The value in Kilowatt.</param>
 	/// <returns>A new HeatFlowRate instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static HeatFlowRate<T> FromKilowatt(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new HeatFlowRate from a value in Megawatt.
 	/// </summary>
 	/// <param name="value">The value in Megawatt.</param>
 	/// <returns>A new HeatFlowRate instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static HeatFlowRate<T> FromMegawatt(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Mega)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new HeatFlowRate from a value in Horsepower.
 	/// </summary>
 	/// <param name="value">The value in Horsepower.</param>
 	/// <returns>A new HeatFlowRate instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static HeatFlowRate<T> FromHorsepower(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.HorsepowerToWatts)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Power unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IPowerUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Power.</summary>
+
+	/// <summary>Implicit conversion to Power.</summary>
 	public static implicit operator Power<T>(HeatFlowRate<T> value) => Power<T>.Create(value.Value);
-/// <summary>Explicit conversion from Power.</summary>
+
+	/// <summary>Explicit conversion from Power.</summary>
 	public static explicit operator HeatFlowRate<T>(Power<T> value) => Create(value.Value);
-/// <summary>Creates a HeatFlowRate from a Power value.</summary>
+
+	/// <summary>Creates a HeatFlowRate from a Power value.</summary>
 	public static HeatFlowRate<T> From(Power<T> value) => Create(value.Value);
-/// <summary>Subtracts two HeatFlowRate values, returning the absolute difference as a non-negative HeatFlowRate.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static HeatFlowRate<T> operator -(HeatFlowRate<T> left, HeatFlowRate<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two HeatFlowRate values, returning the absolute difference as a non-negative HeatFlowRate.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static HeatFlowRate<T> operator -(HeatFlowRate<T> left, HeatFlowRate<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatFlux.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatFlux.g.cs
index 2fd88509..e80848f1 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatFlux.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatFlux.g.cs
@@ -26,20 +26,26 @@ public partial record HeatFlux<T> : PhysicalQuantity<HeatFlux<T>, T>, IVector0<H
 	/// <returns>A new HeatFlux instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static HeatFlux<T> FromWattPerSquareMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Irradiance unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IIrradianceUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Irradiance.</summary>
+
+	/// <summary>Implicit conversion to Irradiance.</summary>
 	public static implicit operator Irradiance<T>(HeatFlux<T> value) => Irradiance<T>.Create(value.Value);
-/// <summary>Explicit conversion from Irradiance.</summary>
+
+	/// <summary>Explicit conversion from Irradiance.</summary>
 	public static explicit operator HeatFlux<T>(Irradiance<T> value) => Create(value.Value);
-/// <summary>Creates a HeatFlux from a Irradiance value.</summary>
+
+	/// <summary>Creates a HeatFlux from a Irradiance value.</summary>
 	public static HeatFlux<T> From(Irradiance<T> value) => Create(value.Value);
-/// <summary>Subtracts two HeatFlux values, returning the absolute difference as a non-negative HeatFlux.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static HeatFlux<T> operator -(HeatFlux<T> left, HeatFlux<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two HeatFlux values, returning the absolute difference as a non-negative HeatFlux.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static HeatFlux<T> operator -(HeatFlux<T> left, HeatFlux<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatTransferCoefficient.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatTransferCoefficient.g.cs
index 456460bc..e3d1ad69 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatTransferCoefficient.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatTransferCoefficient.g.cs
@@ -25,17 +25,20 @@ public partial record HeatTransferCoefficient<T> : PhysicalQuantity<HeatTransfer
 	/// <returns>A new <see cref="HeatTransferCoefficient{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static HeatTransferCoefficient<T> FromWattPerSquareMeterKelvin(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-HeatTransferCoefficient unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IHeatTransferCoefficientUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two HeatTransferCoefficient values, returning the absolute difference as a non-negative HeatTransferCoefficient.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static HeatTransferCoefficient<T> operator -(HeatTransferCoefficient<T> left, HeatTransferCoefficient<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static HeatTransferCoefficient<T> operator -(HeatTransferCoefficient<T> left, HeatTransferCoefficient<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Height.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Height.g.cs
index d8ace7cc..0bb0eee3 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Height.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Height.g.cs
@@ -26,97 +26,114 @@ public partial record Height<T> : PhysicalQuantity<Height<T>, T>, IVector0<Heigh
 	/// <returns>A new Height instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Height<T> FromMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Height from a value in Kilometer.
 	/// </summary>
 	/// <param name="value">The value in Kilometer.</param>
 	/// <returns>A new Height instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Height<T> FromKilometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Height from a value in Centimeter.
 	/// </summary>
 	/// <param name="value">The value in Centimeter.</param>
 	/// <returns>A new Height instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Height<T> FromCentimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Centi)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Height from a value in Millimeter.
 	/// </summary>
 	/// <param name="value">The value in Millimeter.</param>
 	/// <returns>A new Height instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Height<T> FromMillimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Height from a value in Micrometer.
 	/// </summary>
 	/// <param name="value">The value in Micrometer.</param>
 	/// <returns>A new Height instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Height<T> FromMicrometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Height from a value in Nanometer.
 	/// </summary>
 	/// <param name="value">The value in Nanometer.</param>
 	/// <returns>A new Height instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Height<T> FromNanometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Height from a value in Angstrom.
 	/// </summary>
 	/// <param name="value">The value in Angstrom.</param>
 	/// <returns>A new Height instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Height<T> FromAngstrom(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AngstromToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Height from a value in Foot.
 	/// </summary>
 	/// <param name="value">The value in Foot.</param>
 	/// <returns>A new Height instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Height<T> FromFoot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FeetToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Height from a value in Inch.
 	/// </summary>
 	/// <param name="value">The value in Inch.</param>
 	/// <returns>A new Height instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Height<T> FromInch(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.InchesToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Height from a value in Yard.
 	/// </summary>
 	/// <param name="value">The value in Yard.</param>
 	/// <returns>A new Height instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Height<T> FromYard(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YardToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Height from a value in Mile.
 	/// </summary>
 	/// <param name="value">The value in Mile.</param>
 	/// <returns>A new Height instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Height<T> FromMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Height from a value in NauticalMile.
 	/// </summary>
 	/// <param name="value">The value in NauticalMile.</param>
 	/// <returns>A new Height instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Height<T> FromNauticalMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.NauticalMileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Length unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Length.</summary>
+
+	/// <summary>Implicit conversion to Length.</summary>
 	public static implicit operator Length<T>(Height<T> value) => Length<T>.Create(value.Value);
-/// <summary>Explicit conversion from Length.</summary>
+
+	/// <summary>Explicit conversion from Length.</summary>
 	public static explicit operator Height<T>(Length<T> value) => Create(value.Value);
-/// <summary>Creates a Height from a Length value.</summary>
+
+	/// <summary>Creates a Height from a Length value.</summary>
 	public static Height<T> From(Length<T> value) => Create(value.Value);
-/// <summary>Subtracts two Height values, returning the absolute difference as a non-negative Height.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Height<T> operator -(Height<T> left, Height<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Height values, returning the absolute difference as a non-negative Height.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Height<T> operator -(Height<T> left, Height<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Illuminance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Illuminance.g.cs
index de341301..ec92d7ab 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Illuminance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Illuminance.g.cs
@@ -25,28 +25,34 @@ public partial record Illuminance<T> : PhysicalQuantity<Illuminance<T>, T>, IVec
 	/// <returns>A new <see cref="Illuminance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Illuminance<T> FromLux(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Illuminance{T}"/> from a value in FootCandle.
 	/// </summary>
 	/// <param name="value">The value in FootCandle.</param>
 	/// <returns>A new <see cref="Illuminance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Illuminance<T> FromFootCandle(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FootCandleToLux)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Illuminance unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IIlluminanceUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Illuminance values, returning the absolute difference as a non-negative Illuminance.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Illuminance<T> operator -(Illuminance<T> left, Illuminance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Illuminance<T> operator -(Illuminance<T> left, Illuminance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Illuminance by Area to produce LuminousFlux.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static LuminousFlux<T> operator *(Illuminance<T> left, Area<T> right) => Multiply<LuminousFlux<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static LuminousFlux<T> operator *(Illuminance<T> left, Area<T> right) => Multiply<LuminousFlux<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Impedance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Impedance.g.cs
index 8f881d97..ef8904d9 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Impedance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Impedance.g.cs
@@ -26,34 +26,42 @@ public partial record Impedance<T> : PhysicalQuantity<Impedance<T>, T>, IVector0
 	/// <returns>A new Impedance instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Impedance<T> FromOhm(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Impedance from a value in Kilohm.
 	/// </summary>
 	/// <param name="value">The value in Kilohm.</param>
 	/// <returns>A new Impedance instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Impedance<T> FromKilohm(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Impedance from a value in Megohm.
 	/// </summary>
 	/// <param name="value">The value in Megohm.</param>
 	/// <returns>A new Impedance instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Impedance<T> FromMegohm(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Mega)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricResistance unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricResistanceUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Resistance.</summary>
+
+	/// <summary>Implicit conversion to Resistance.</summary>
 	public static implicit operator Resistance<T>(Impedance<T> value) => Resistance<T>.Create(value.Value);
-/// <summary>Explicit conversion from Resistance.</summary>
+
+	/// <summary>Explicit conversion from Resistance.</summary>
 	public static explicit operator Impedance<T>(Resistance<T> value) => Create(value.Value);
-/// <summary>Creates a Impedance from a Resistance value.</summary>
+
+	/// <summary>Creates a Impedance from a Resistance value.</summary>
 	public static Impedance<T> From(Resistance<T> value) => Create(value.Value);
-/// <summary>Subtracts two Impedance values, returning the absolute difference as a non-negative Impedance.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Impedance<T> operator -(Impedance<T> left, Impedance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Impedance values, returning the absolute difference as a non-negative Impedance.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Impedance<T> operator -(Impedance<T> left, Impedance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Inductance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Inductance.g.cs
index 7b67a249..c58a7812 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Inductance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Inductance.g.cs
@@ -25,21 +25,26 @@ public partial record Inductance<T> : PhysicalQuantity<Inductance<T>, T>, IVecto
 	/// <returns>A new <see cref="Inductance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Inductance<T> FromHenry(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Inductance unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IInductanceUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Inductance values, returning the absolute difference as a non-negative Inductance.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Inductance<T> operator -(Inductance<T> left, Inductance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Inductance<T> operator -(Inductance<T> left, Inductance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Inductance by CurrentMagnitude to produce MagneticFlux.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MagneticFlux<T> operator *(Inductance<T> left, CurrentMagnitude<T> right) => Multiply<MagneticFlux<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFlux<T> operator *(Inductance<T> left, CurrentMagnitude<T> right) => Multiply<MagneticFlux<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Irradiance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Irradiance.g.cs
index e1578186..397f3f12 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Irradiance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Irradiance.g.cs
@@ -25,21 +25,26 @@ public partial record Irradiance<T> : PhysicalQuantity<Irradiance<T>, T>, IVecto
 	/// <returns>A new <see cref="Irradiance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Irradiance<T> FromWattPerSquareMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Irradiance unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IIrradianceUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Irradiance values, returning the absolute difference as a non-negative Irradiance.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Irradiance<T> operator -(Irradiance<T> left, Irradiance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Irradiance<T> operator -(Irradiance<T> left, Irradiance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Irradiance by Area to produce Power.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Power<T> operator *(Irradiance<T> left, Area<T> right) => Multiply<Power<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(Irradiance<T> left, Area<T> right) => Multiply<Power<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk1D.g.cs
index dc42bdb6..3c023d5d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk1D.g.cs
@@ -24,25 +24,31 @@ public partial record Jerk1D<T> : PhysicalQuantity<Jerk1D<T>, T>, IVector1<Jerk1
 	/// <param name="value">The value in MeterPerSecondCubed.</param>
 	/// <returns>A new <see cref="Jerk1D{T}"/> instance.</returns>
 	public static Jerk1D<T> FromMeterPerSecondCubed(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Jerk unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IJerkUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="JerkMagnitude{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public JerkMagnitude<T> Magnitude() => JerkMagnitude<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Multiplies Jerk1D by Duration to produce Acceleration1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Acceleration1D<T> operator *(Jerk1D<T> left, Duration<T> right) => Multiply<Acceleration1D<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration1D<T> operator *(Jerk1D<T> left, Duration<T> right) => Multiply<Acceleration1D<T>>(left, right);
+
+	/// <summary>
 	/// Divides Jerk1D by Duration to produce Snap1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Snap1D<T> operator /(Jerk1D<T> left, Duration<T> right) => Divide<Snap1D<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Snap1D<T> operator /(Jerk1D<T> left, Duration<T> right) => Divide<Snap1D<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/JerkMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/JerkMagnitude.g.cs
index 90cbef21..dca9ea3c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/JerkMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/JerkMagnitude.g.cs
@@ -25,29 +25,38 @@ public partial record JerkMagnitude<T> : PhysicalQuantity<JerkMagnitude<T>, T>,
 	/// <returns>A new <see cref="JerkMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static JerkMagnitude<T> FromMeterPerSecondCubed(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Jerk unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IJerkUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two JerkMagnitude values, returning the absolute difference as a non-negative JerkMagnitude.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static JerkMagnitude<T> operator -(JerkMagnitude<T> left, JerkMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static JerkMagnitude<T> operator -(JerkMagnitude<T> left, JerkMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies JerkMagnitude by Duration to produce AccelerationMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AccelerationMagnitude<T> operator *(JerkMagnitude<T> left, Duration<T> right) => Multiply<AccelerationMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator *(JerkMagnitude<T> left, Duration<T> right) => Multiply<AccelerationMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides JerkMagnitude by Duration to produce SnapMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SnapMagnitude<T> operator /(JerkMagnitude<T> left, Duration<T> right) => Divide<SnapMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SnapMagnitude<T> operator /(JerkMagnitude<T> left, Duration<T> right) => Divide<SnapMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides JerkMagnitude by SnapMagnitude to produce Duration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Duration<T> operator /(JerkMagnitude<T> left, SnapMagnitude<T> right) => Divide<Duration<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(JerkMagnitude<T> left, SnapMagnitude<T> right) => Divide<Duration<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/KinematicViscosity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/KinematicViscosity.g.cs
index c3cfe25d..70f066f9 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/KinematicViscosity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/KinematicViscosity.g.cs
@@ -25,28 +25,34 @@ public partial record KinematicViscosity<T> : PhysicalQuantity<KinematicViscosit
 	/// <returns>A new <see cref="KinematicViscosity{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static KinematicViscosity<T> FromSquareMeterPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="KinematicViscosity{T}"/> from a value in Stokes.
 	/// </summary>
 	/// <param name="value">The value in Stokes.</param>
 	/// <returns>A new <see cref="KinematicViscosity{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static KinematicViscosity<T> FromStokes(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.StokesToSquareMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-KinematicViscosity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IKinematicViscosityUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two KinematicViscosity values, returning the absolute difference as a non-negative KinematicViscosity.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static KinematicViscosity<T> operator -(KinematicViscosity<T> left, KinematicViscosity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static KinematicViscosity<T> operator -(KinematicViscosity<T> left, KinematicViscosity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies KinematicViscosity by Density to produce DynamicViscosity.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static DynamicViscosity<T> operator *(KinematicViscosity<T> left, Density<T> right) => Multiply<DynamicViscosity<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static DynamicViscosity<T> operator *(KinematicViscosity<T> left, Density<T> right) => Multiply<DynamicViscosity<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/KineticEnergy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/KineticEnergy.g.cs
index b0d283f7..0f8f19c7 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/KineticEnergy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/KineticEnergy.g.cs
@@ -26,76 +26,90 @@ public partial record KineticEnergy<T> : PhysicalQuantity<KineticEnergy<T>, T>,
 	/// <returns>A new KineticEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static KineticEnergy<T> FromJoule(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new KineticEnergy from a value in Kilojoule.
 	/// </summary>
 	/// <param name="value">The value in Kilojoule.</param>
 	/// <returns>A new KineticEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static KineticEnergy<T> FromKilojoule(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new KineticEnergy from a value in ElectronVolt.
 	/// </summary>
 	/// <param name="value">The value in ElectronVolt.</param>
 	/// <returns>A new KineticEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static KineticEnergy<T> FromElectronVolt(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.ElectronVoltToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new KineticEnergy from a value in Calorie.
 	/// </summary>
 	/// <param name="value">The value in Calorie.</param>
 	/// <returns>A new KineticEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static KineticEnergy<T> FromCalorie(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.CalorieToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new KineticEnergy from a value in Kilocalorie.
 	/// </summary>
 	/// <param name="value">The value in Kilocalorie.</param>
 	/// <returns>A new KineticEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static KineticEnergy<T> FromKilocalorie(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilocalorieToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new KineticEnergy from a value in KilowattHour.
 	/// </summary>
 	/// <param name="value">The value in KilowattHour.</param>
 	/// <returns>A new KineticEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static KineticEnergy<T> FromKilowattHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilowattHourToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new KineticEnergy from a value in WattHour.
 	/// </summary>
 	/// <param name="value">The value in WattHour.</param>
 	/// <returns>A new KineticEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static KineticEnergy<T> FromWattHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.WattHourToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new KineticEnergy from a value in Erg.
 	/// </summary>
 	/// <param name="value">The value in Erg.</param>
 	/// <returns>A new KineticEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static KineticEnergy<T> FromErg(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.ErgToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new KineticEnergy from a value in Btu.
 	/// </summary>
 	/// <param name="value">The value in Btu.</param>
 	/// <returns>A new KineticEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static KineticEnergy<T> FromBtu(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.BtuToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Energy unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IEnergyUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Energy.</summary>
+
+	/// <summary>Implicit conversion to Energy.</summary>
 	public static implicit operator Energy<T>(KineticEnergy<T> value) => Energy<T>.Create(value.Value);
-/// <summary>Explicit conversion from Energy.</summary>
+
+	/// <summary>Explicit conversion from Energy.</summary>
 	public static explicit operator KineticEnergy<T>(Energy<T> value) => Create(value.Value);
-/// <summary>Creates a KineticEnergy from a Energy value.</summary>
+
+	/// <summary>Creates a KineticEnergy from a Energy value.</summary>
 	public static KineticEnergy<T> From(Energy<T> value) => Create(value.Value);
-/// <summary>Subtracts two KineticEnergy values, returning the absolute difference as a non-negative KineticEnergy.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static KineticEnergy<T> operator -(KineticEnergy<T> left, KineticEnergy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two KineticEnergy values, returning the absolute difference as a non-negative KineticEnergy.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static KineticEnergy<T> operator -(KineticEnergy<T> left, KineticEnergy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Latency.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Latency.g.cs
index a1aeb72e..ee090178 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Latency.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Latency.g.cs
@@ -26,76 +26,90 @@ public partial record Latency<T> : PhysicalQuantity<Latency<T>, T>, IVector0<Lat
 	/// <returns>A new Latency instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Latency<T> FromSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Latency from a value in Millisecond.
 	/// </summary>
 	/// <param name="value">The value in Millisecond.</param>
 	/// <returns>A new Latency instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Latency<T> FromMillisecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Latency from a value in Microsecond.
 	/// </summary>
 	/// <param name="value">The value in Microsecond.</param>
 	/// <returns>A new Latency instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Latency<T> FromMicrosecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Latency from a value in Minute.
 	/// </summary>
 	/// <param name="value">The value in Minute.</param>
 	/// <returns>A new Latency instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Latency<T> FromMinute(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MinuteToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Latency from a value in Hour.
 	/// </summary>
 	/// <param name="value">The value in Hour.</param>
 	/// <returns>A new Latency instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Latency<T> FromHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.HourToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Latency from a value in Day.
 	/// </summary>
 	/// <param name="value">The value in Day.</param>
 	/// <returns>A new Latency instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Latency<T> FromDay(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DayToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Latency from a value in Year.
 	/// </summary>
 	/// <param name="value">The value in Year.</param>
 	/// <returns>A new Latency instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Latency<T> FromYear(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YearToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Latency from a value in Week.
 	/// </summary>
 	/// <param name="value">The value in Week.</param>
 	/// <returns>A new Latency instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Latency<T> FromWeek(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.WeekToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Latency from a value in Nanosecond.
 	/// </summary>
 	/// <param name="value">The value in Nanosecond.</param>
 	/// <returns>A new Latency instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Latency<T> FromNanosecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Time unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ITimeUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Duration.</summary>
+
+	/// <summary>Implicit conversion to Duration.</summary>
 	public static implicit operator Duration<T>(Latency<T> value) => Duration<T>.Create(value.Value);
-/// <summary>Explicit conversion from Duration.</summary>
+
+	/// <summary>Explicit conversion from Duration.</summary>
 	public static explicit operator Latency<T>(Duration<T> value) => Create(value.Value);
-/// <summary>Creates a Latency from a Duration value.</summary>
+
+	/// <summary>Creates a Latency from a Duration value.</summary>
 	public static Latency<T> From(Duration<T> value) => Create(value.Value);
-/// <summary>Subtracts two Latency values, returning the absolute difference as a non-negative Latency.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Latency<T> operator -(Latency<T> left, Latency<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Latency values, returning the absolute difference as a non-negative Latency.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Latency<T> operator -(Latency<T> left, Latency<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Length.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Length.g.cs
index 48458235..66842dd2 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Length.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Length.g.cs
@@ -25,130 +25,162 @@ public partial record Length<T> : PhysicalQuantity<Length<T>, T>, IVector0<Lengt
 	/// <returns>A new <see cref="Length{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Length<T> FromMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Length{T}"/> from a value in Kilometer.
 	/// </summary>
 	/// <param name="value">The value in Kilometer.</param>
 	/// <returns>A new <see cref="Length{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Length<T> FromKilometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Length{T}"/> from a value in Centimeter.
 	/// </summary>
 	/// <param name="value">The value in Centimeter.</param>
 	/// <returns>A new <see cref="Length{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Length<T> FromCentimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Centi)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Length{T}"/> from a value in Millimeter.
 	/// </summary>
 	/// <param name="value">The value in Millimeter.</param>
 	/// <returns>A new <see cref="Length{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Length<T> FromMillimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Length{T}"/> from a value in Micrometer.
 	/// </summary>
 	/// <param name="value">The value in Micrometer.</param>
 	/// <returns>A new <see cref="Length{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Length<T> FromMicrometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Length{T}"/> from a value in Nanometer.
 	/// </summary>
 	/// <param name="value">The value in Nanometer.</param>
 	/// <returns>A new <see cref="Length{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Length<T> FromNanometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Length{T}"/> from a value in Angstrom.
 	/// </summary>
 	/// <param name="value">The value in Angstrom.</param>
 	/// <returns>A new <see cref="Length{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Length<T> FromAngstrom(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AngstromToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Length{T}"/> from a value in Foot.
 	/// </summary>
 	/// <param name="value">The value in Foot.</param>
 	/// <returns>A new <see cref="Length{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Length<T> FromFoot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FeetToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Length{T}"/> from a value in Inch.
 	/// </summary>
 	/// <param name="value">The value in Inch.</param>
 	/// <returns>A new <see cref="Length{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Length<T> FromInch(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.InchesToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Length{T}"/> from a value in Yard.
 	/// </summary>
 	/// <param name="value">The value in Yard.</param>
 	/// <returns>A new <see cref="Length{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Length<T> FromYard(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YardToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Length{T}"/> from a value in Mile.
 	/// </summary>
 	/// <param name="value">The value in Mile.</param>
 	/// <returns>A new <see cref="Length{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Length<T> FromMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Length{T}"/> from a value in NauticalMile.
 	/// </summary>
 	/// <param name="value">The value in NauticalMile.</param>
 	/// <returns>A new <see cref="Length{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Length<T> FromNauticalMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.NauticalMileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Length unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Length values, returning the absolute difference as a non-negative Length.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Length<T> operator -(Length<T> left, Length<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator -(Length<T> left, Length<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Length by Length to produce Area.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Area<T> operator *(Length<T> left, Length<T> right) => Multiply<Area<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator *(Length<T> left, Length<T> right) => Multiply<Area<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Length by Area to produce Volume.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Volume<T> operator *(Length<T> left, Area<T> right) => Multiply<Volume<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(Length<T> left, Area<T> right) => Multiply<Volume<T>>(left, right);
+
+	/// <summary>
 	/// Divides Length by Duration to produce Speed.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Speed<T> operator /(Length<T> left, Duration<T> right) => Divide<Speed<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator /(Length<T> left, Duration<T> right) => Divide<Speed<T>>(left, right);
+
+	/// <summary>
 	/// Divides Length by Speed to produce Duration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Duration<T> operator /(Length<T> left, Speed<T> right) => Divide<Duration<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Length<T> left, Speed<T> right) => Divide<Duration<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Length by Frequency to produce Speed.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Speed<T> operator *(Length<T> left, Frequency<T> right) => Multiply<Speed<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(Length<T> left, Frequency<T> right) => Multiply<Speed<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Length by ForceMagnitude to produce Energy.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Energy<T> operator *(Length<T> left, ForceMagnitude<T> right) => Multiply<Energy<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Length<T> left, ForceMagnitude<T> right) => Multiply<Energy<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Length by ElectricFieldMagnitude to produce VoltageMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static VoltageMagnitude<T> operator *(Length<T> left, ElectricFieldMagnitude<T> right) => Multiply<VoltageMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(Length<T> left, ElectricFieldMagnitude<T> right) => Multiply<VoltageMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Length by ElectricField1D to produce Voltage.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Voltage<T> operator *(Length<T> left, ElectricField1D<T> right) => Multiply<Voltage<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Voltage<T> operator *(Length<T> left, ElectricField1D<T> right) => Multiply<Voltage<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Length by SurfaceTension to produce ForceMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ForceMagnitude<T> operator *(Length<T> left, SurfaceTension<T> right) => Multiply<ForceMagnitude<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(Length<T> left, SurfaceTension<T> right) => Multiply<ForceMagnitude<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Lift.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Lift.g.cs
index 57b55541..40e4a802 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Lift.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Lift.g.cs
@@ -26,41 +26,50 @@ public partial record Lift<T> : PhysicalQuantity<Lift<T>, T>, IVector0<Lift<T>,
 	/// <returns>A new Lift instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Lift<T> FromNewton(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Lift from a value in Kilonewton.
 	/// </summary>
 	/// <param name="value">The value in Kilonewton.</param>
 	/// <returns>A new Lift instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Lift<T> FromKilonewton(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Lift from a value in Dyne.
 	/// </summary>
 	/// <param name="value">The value in Dyne.</param>
 	/// <returns>A new Lift instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Lift<T> FromDyne(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DyneToNewtons)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Lift from a value in PoundForce.
 	/// </summary>
 	/// <param name="value">The value in PoundForce.</param>
 	/// <returns>A new Lift instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Lift<T> FromPoundForce(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PoundForceToNewtons)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Force unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IForceUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to ForceMagnitude.</summary>
+
+	/// <summary>Implicit conversion to ForceMagnitude.</summary>
 	public static implicit operator ForceMagnitude<T>(Lift<T> value) => ForceMagnitude<T>.Create(value.Value);
-/// <summary>Explicit conversion from ForceMagnitude.</summary>
+
+	/// <summary>Explicit conversion from ForceMagnitude.</summary>
 	public static explicit operator Lift<T>(ForceMagnitude<T> value) => Create(value.Value);
-/// <summary>Creates a Lift from a ForceMagnitude value.</summary>
+
+	/// <summary>Creates a Lift from a ForceMagnitude value.</summary>
 	public static Lift<T> From(ForceMagnitude<T> value) => Create(value.Value);
-/// <summary>Subtracts two Lift values, returning the absolute difference as a non-negative Lift.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Lift<T> operator -(Lift<T> left, Lift<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Lift values, returning the absolute difference as a non-negative Lift.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Lift<T> operator -(Lift<T> left, Lift<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Loudness.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Loudness.g.cs
index 7bddc858..90d30cfa 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Loudness.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Loudness.g.cs
@@ -25,17 +25,20 @@ public partial record Loudness<T> : PhysicalQuantity<Loudness<T>, T>, IVector0<L
 	/// <returns>A new <see cref="Loudness{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Loudness<T> FromSone(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Loudness unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ILoudnessUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Loudness values, returning the absolute difference as a non-negative Loudness.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Loudness<T> operator -(Loudness<T> left, Loudness<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Loudness<T> operator -(Loudness<T> left, Loudness<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Luminance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Luminance.g.cs
index 517e88f8..815ac77e 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Luminance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Luminance.g.cs
@@ -25,35 +25,42 @@ public partial record Luminance<T> : PhysicalQuantity<Luminance<T>, T>, IVector0
 	/// <returns>A new <see cref="Luminance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Luminance<T> FromCandelaPerSquareMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Luminance{T}"/> from a value in Nit.
 	/// </summary>
 	/// <param name="value">The value in Nit.</param>
 	/// <returns>A new <see cref="Luminance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Luminance<T> FromNit(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Luminance{T}"/> from a value in FootLambert.
 	/// </summary>
 	/// <param name="value">The value in FootLambert.</param>
 	/// <returns>A new <see cref="Luminance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Luminance<T> FromFootLambert(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FootLambertToCandelaPerSquareMeter)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Luminance unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ILuminanceUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Luminance values, returning the absolute difference as a non-negative Luminance.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Luminance<T> operator -(Luminance<T> left, Luminance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Luminance<T> operator -(Luminance<T> left, Luminance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Luminance by Area to produce LuminousIntensity.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static LuminousIntensity<T> operator *(Luminance<T> left, Area<T> right) => Multiply<LuminousIntensity<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static LuminousIntensity<T> operator *(Luminance<T> left, Area<T> right) => Multiply<LuminousIntensity<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/LuminousFlux.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/LuminousFlux.g.cs
index bc7060cc..d762a7eb 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/LuminousFlux.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/LuminousFlux.g.cs
@@ -25,25 +25,32 @@ public partial record LuminousFlux<T> : PhysicalQuantity<LuminousFlux<T>, T>, IV
 	/// <returns>A new <see cref="LuminousFlux{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static LuminousFlux<T> FromLumen(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-LuminousFlux unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ILuminousFluxUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two LuminousFlux values, returning the absolute difference as a non-negative LuminousFlux.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static LuminousFlux<T> operator -(LuminousFlux<T> left, LuminousFlux<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static LuminousFlux<T> operator -(LuminousFlux<T> left, LuminousFlux<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Divides LuminousFlux by Area to produce Illuminance.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Illuminance<T> operator /(LuminousFlux<T> left, Area<T> right) => Divide<Illuminance<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Illuminance<T> operator /(LuminousFlux<T> left, Area<T> right) => Divide<Illuminance<T>>(left, right);
+
+	/// <summary>
 	/// Divides LuminousFlux by Illuminance to produce Area.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Area<T> operator /(LuminousFlux<T> left, Illuminance<T> right) => Divide<Area<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator /(LuminousFlux<T> left, Illuminance<T> right) => Divide<Area<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/LuminousIntensity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/LuminousIntensity.g.cs
index 5536d6b7..fc68cf7e 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/LuminousIntensity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/LuminousIntensity.g.cs
@@ -25,32 +25,40 @@ public partial record LuminousIntensity<T> : PhysicalQuantity<LuminousIntensity<
 	/// <returns>A new <see cref="LuminousIntensity{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static LuminousIntensity<T> FromCandela(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="LuminousIntensity{T}"/> from a value in Millicandela.
 	/// </summary>
 	/// <param name="value">The value in Millicandela.</param>
 	/// <returns>A new <see cref="LuminousIntensity{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static LuminousIntensity<T> FromMillicandela(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-LuminousIntensity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ILuminousIntensityUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two LuminousIntensity values, returning the absolute difference as a non-negative LuminousIntensity.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static LuminousIntensity<T> operator -(LuminousIntensity<T> left, LuminousIntensity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static LuminousIntensity<T> operator -(LuminousIntensity<T> left, LuminousIntensity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Divides LuminousIntensity by Area to produce Luminance.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Luminance<T> operator /(LuminousIntensity<T> left, Area<T> right) => Divide<Luminance<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Luminance<T> operator /(LuminousIntensity<T> left, Area<T> right) => Divide<Luminance<T>>(left, right);
+
+	/// <summary>
 	/// Divides LuminousIntensity by Luminance to produce Area.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Area<T> operator /(LuminousIntensity<T> left, Luminance<T> right) => Divide<Area<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator /(LuminousIntensity<T> left, Luminance<T> right) => Divide<Area<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MachNumber.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MachNumber.g.cs
index bfca93d9..16e030c3 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MachNumber.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MachNumber.g.cs
@@ -26,83 +26,98 @@ public partial record MachNumber<T> : PhysicalQuantity<MachNumber<T>, T>, IVecto
 	/// <returns>A new MachNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MachNumber<T> FromDimensionless(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new MachNumber from a value in Radian.
 	/// </summary>
 	/// <param name="value">The value in Radian.</param>
 	/// <returns>A new MachNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MachNumber<T> FromRadian(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new MachNumber from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new MachNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MachNumber<T> FromDegree(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new MachNumber from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new MachNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MachNumber<T> FromGradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new MachNumber from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new MachNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MachNumber<T> FromRevolution(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new MachNumber from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new MachNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MachNumber<T> FromMilliradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new MachNumber from a value in Percent.
 	/// </summary>
 	/// <param name="value">The value in Percent.</param>
 	/// <returns>A new MachNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MachNumber<T> FromPercent(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new MachNumber from a value in PartPerMillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerMillion.</param>
 	/// <returns>A new MachNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MachNumber<T> FromPartPerMillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerMillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new MachNumber from a value in PartPerBillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerBillion.</param>
 	/// <returns>A new MachNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MachNumber<T> FromPartPerBillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerBillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new MachNumber from a value in PercentByWeight.
 	/// </summary>
 	/// <param name="value">The value in PercentByWeight.</param>
 	/// <returns>A new MachNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MachNumber<T> FromPercentByWeight(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentByWeightToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Dimensionless unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IDimensionlessUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Ratio.</summary>
+
+	/// <summary>Implicit conversion to Ratio.</summary>
 	public static implicit operator Ratio<T>(MachNumber<T> value) => Ratio<T>.Create(value.Value);
-/// <summary>Explicit conversion from Ratio.</summary>
+
+	/// <summary>Explicit conversion from Ratio.</summary>
 	public static explicit operator MachNumber<T>(Ratio<T> value) => Create(value.Value);
-/// <summary>Creates a MachNumber from a Ratio value.</summary>
+
+	/// <summary>Creates a MachNumber from a Ratio value.</summary>
 	public static MachNumber<T> From(Ratio<T> value) => Create(value.Value);
-/// <summary>Subtracts two MachNumber values, returning the absolute difference as a non-negative MachNumber.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MachNumber<T> operator -(MachNumber<T> left, MachNumber<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two MachNumber values, returning the absolute difference as a non-negative MachNumber.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MachNumber<T> operator -(MachNumber<T> left, MachNumber<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFlux.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFlux.g.cs
index b2078106..c9b498bd 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFlux.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFlux.g.cs
@@ -25,37 +25,50 @@ public partial record MagneticFlux<T> : PhysicalQuantity<MagneticFlux<T>, T>, IV
 	/// <returns>A new <see cref="MagneticFlux{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MagneticFlux<T> FromWeber(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-MagneticFlux unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IMagneticFluxUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two MagneticFlux values, returning the absolute difference as a non-negative MagneticFlux.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MagneticFlux<T> operator -(MagneticFlux<T> left, MagneticFlux<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFlux<T> operator -(MagneticFlux<T> left, MagneticFlux<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Divides MagneticFlux by Area to produce MagneticFluxDensityMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MagneticFluxDensityMagnitude<T> operator /(MagneticFlux<T> left, Area<T> right) => Divide<MagneticFluxDensityMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFluxDensityMagnitude<T> operator /(MagneticFlux<T> left, Area<T> right) => Divide<MagneticFluxDensityMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides MagneticFlux by MagneticFluxDensityMagnitude to produce Area.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Area<T> operator /(MagneticFlux<T> left, MagneticFluxDensityMagnitude<T> right) => Divide<Area<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator /(MagneticFlux<T> left, MagneticFluxDensityMagnitude<T> right) => Divide<Area<T>>(left, right);
+
+	/// <summary>
 	/// Divides MagneticFlux by Duration to produce VoltageMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static VoltageMagnitude<T> operator /(MagneticFlux<T> left, Duration<T> right) => Divide<VoltageMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator /(MagneticFlux<T> left, Duration<T> right) => Divide<VoltageMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides MagneticFlux by CurrentMagnitude to produce Inductance.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Inductance<T> operator /(MagneticFlux<T> left, CurrentMagnitude<T> right) => Divide<Inductance<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Inductance<T> operator /(MagneticFlux<T> left, CurrentMagnitude<T> right) => Divide<Inductance<T>>(left, right);
+
+	/// <summary>
 	/// Divides MagneticFlux by Inductance to produce CurrentMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static CurrentMagnitude<T> operator /(MagneticFlux<T> left, Inductance<T> right) => Divide<CurrentMagnitude<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static CurrentMagnitude<T> operator /(MagneticFlux<T> left, Inductance<T> right) => Divide<CurrentMagnitude<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFluxDensityMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFluxDensityMagnitude.g.cs
index 98456ddb..04c174f1 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFluxDensityMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFluxDensityMagnitude.g.cs
@@ -25,28 +25,34 @@ public partial record MagneticFluxDensityMagnitude<T> : PhysicalQuantity<Magneti
 	/// <returns>A new <see cref="MagneticFluxDensityMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MagneticFluxDensityMagnitude<T> FromTesla(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="MagneticFluxDensityMagnitude{T}"/> from a value in Gauss.
 	/// </summary>
 	/// <param name="value">The value in Gauss.</param>
 	/// <returns>A new <see cref="MagneticFluxDensityMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MagneticFluxDensityMagnitude<T> FromGauss(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GaussToTesla)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-MagneticFluxDensity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IMagneticFluxDensityUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two MagneticFluxDensityMagnitude values, returning the absolute difference as a non-negative MagneticFluxDensityMagnitude.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MagneticFluxDensityMagnitude<T> operator -(MagneticFluxDensityMagnitude<T> left, MagneticFluxDensityMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFluxDensityMagnitude<T> operator -(MagneticFluxDensityMagnitude<T> left, MagneticFluxDensityMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies MagneticFluxDensityMagnitude by Area to produce MagneticFlux.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MagneticFlux<T> operator *(MagneticFluxDensityMagnitude<T> left, Area<T> right) => Multiply<MagneticFlux<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFlux<T> operator *(MagneticFluxDensityMagnitude<T> left, Area<T> right) => Multiply<MagneticFlux<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Mass.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Mass.g.cs
index eaac7576..9adb0fca 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Mass.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Mass.g.cs
@@ -25,102 +25,130 @@ public partial record Mass<T> : PhysicalQuantity<Mass<T>, T>, IVector0<Mass<T>,
 	/// <returns>A new <see cref="Mass{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Mass<T> FromKilogram(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Mass{T}"/> from a value in Gram.
 	/// </summary>
 	/// <param name="value">The value in Gram.</param>
 	/// <returns>A new <see cref="Mass{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Mass<T> FromGram(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Mass{T}"/> from a value in Ton.
 	/// </summary>
 	/// <param name="value">The value in Ton.</param>
 	/// <returns>A new <see cref="Mass{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Mass<T> FromTon(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.TonToKilograms)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Mass{T}"/> from a value in Pound.
 	/// </summary>
 	/// <param name="value">The value in Pound.</param>
 	/// <returns>A new <see cref="Mass{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Mass<T> FromPound(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PoundToKilograms)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Mass{T}"/> from a value in Ounce.
 	/// </summary>
 	/// <param name="value">The value in Ounce.</param>
 	/// <returns>A new <see cref="Mass{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Mass<T> FromOunce(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.OunceToKilograms)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Mass{T}"/> from a value in Stone.
 	/// </summary>
 	/// <param name="value">The value in Stone.</param>
 	/// <returns>A new <see cref="Mass{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Mass<T> FromStone(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.StoneToKilograms)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Mass{T}"/> from a value in ShortTon.
 	/// </summary>
 	/// <param name="value">The value in ShortTon.</param>
 	/// <returns>A new <see cref="Mass{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Mass<T> FromShortTon(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.ShortTonToKilograms)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Mass{T}"/> from a value in AtomicMassUnit.
 	/// </summary>
 	/// <param name="value">The value in AtomicMassUnit.</param>
 	/// <returns>A new <see cref="Mass{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Mass<T> FromAtomicMassUnit(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AtomicMassUnitToKilograms)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Mass unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IMassUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Mass values, returning the absolute difference as a non-negative Mass.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Mass<T> operator -(Mass<T> left, Mass<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator -(Mass<T> left, Mass<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Mass by AccelerationMagnitude to produce ForceMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ForceMagnitude<T> operator *(Mass<T> left, AccelerationMagnitude<T> right) => Multiply<ForceMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(Mass<T> left, AccelerationMagnitude<T> right) => Multiply<ForceMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Mass by Speed to produce MomentumMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MomentumMagnitude<T> operator *(Mass<T> left, Speed<T> right) => Multiply<MomentumMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(Mass<T> left, Speed<T> right) => Multiply<MomentumMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides Mass by Volume to produce Density.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Density<T> operator /(Mass<T> left, Volume<T> right) => Divide<Density<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Density<T> operator /(Mass<T> left, Volume<T> right) => Divide<Density<T>>(left, right);
+
+	/// <summary>
 	/// Divides Mass by Density to produce Volume.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Volume<T> operator /(Mass<T> left, Density<T> right) => Divide<Volume<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator /(Mass<T> left, Density<T> right) => Divide<Volume<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Mass by SpecificHeat to produce Entropy.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Entropy<T> operator *(Mass<T> left, SpecificHeat<T> right) => Multiply<Entropy<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Entropy<T> operator *(Mass<T> left, SpecificHeat<T> right) => Multiply<Entropy<T>>(left, right);
+
+	/// <summary>
 	/// Divides Mass by Duration to produce MassFlowRate.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MassFlowRate<T> operator /(Mass<T> left, Duration<T> right) => Divide<MassFlowRate<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MassFlowRate<T> operator /(Mass<T> left, Duration<T> right) => Divide<MassFlowRate<T>>(left, right);
+
+	/// <summary>
 	/// Divides Mass by MassFlowRate to produce Duration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Duration<T> operator /(Mass<T> left, MassFlowRate<T> right) => Divide<Duration<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Mass<T> left, MassFlowRate<T> right) => Divide<Duration<T>>(left, right);
+
+	/// <summary>
 	/// Divides Mass by AmountOfSubstance to produce MolarMass.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MolarMass<T> operator /(Mass<T> left, AmountOfSubstance<T> right) => Divide<MolarMass<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MolarMass<T> operator /(Mass<T> left, AmountOfSubstance<T> right) => Divide<MolarMass<T>>(left, right);
+
+	/// <summary>
 	/// Divides Mass by MolarMass to produce AmountOfSubstance.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AmountOfSubstance<T> operator /(Mass<T> left, MolarMass<T> right) => Divide<AmountOfSubstance<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator /(Mass<T> left, MolarMass<T> right) => Divide<AmountOfSubstance<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MassFlowRate.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MassFlowRate.g.cs
index aeaa2440..8b67bc84 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MassFlowRate.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MassFlowRate.g.cs
@@ -25,21 +25,26 @@ public partial record MassFlowRate<T> : PhysicalQuantity<MassFlowRate<T>, T>, IV
 	/// <returns>A new <see cref="MassFlowRate{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MassFlowRate<T> FromKilogramPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-MassFlowRate unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IMassFlowRateUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two MassFlowRate values, returning the absolute difference as a non-negative MassFlowRate.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MassFlowRate<T> operator -(MassFlowRate<T> left, MassFlowRate<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MassFlowRate<T> operator -(MassFlowRate<T> left, MassFlowRate<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies MassFlowRate by Duration to produce Mass.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Mass<T> operator *(MassFlowRate<T> left, Duration<T> right) => Multiply<Mass<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator *(MassFlowRate<T> left, Duration<T> right) => Multiply<Mass<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarEnergy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarEnergy.g.cs
index d6737700..406ae72f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarEnergy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarEnergy.g.cs
@@ -25,35 +25,42 @@ public partial record MolarEnergy<T> : PhysicalQuantity<MolarEnergy<T>, T>, IVec
 	/// <returns>A new <see cref="MolarEnergy{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MolarEnergy<T> FromJoulePerMole(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="MolarEnergy{T}"/> from a value in KilojoulePerMole.
 	/// </summary>
 	/// <param name="value">The value in KilojoulePerMole.</param>
 	/// <returns>A new <see cref="MolarEnergy{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MolarEnergy<T> FromKilojoulePerMole(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilojoulePerMoleToJoulePerMole)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="MolarEnergy{T}"/> from a value in CaloriePerMole.
 	/// </summary>
 	/// <param name="value">The value in CaloriePerMole.</param>
 	/// <returns>A new <see cref="MolarEnergy{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MolarEnergy<T> FromCaloriePerMole(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.CaloriePerMoleToJoulePerMole)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-MolarEnergy unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IMolarEnergyUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two MolarEnergy values, returning the absolute difference as a non-negative MolarEnergy.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MolarEnergy<T> operator -(MolarEnergy<T> left, MolarEnergy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MolarEnergy<T> operator -(MolarEnergy<T> left, MolarEnergy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies MolarEnergy by AmountOfSubstance to produce Energy.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Energy<T> operator *(MolarEnergy<T> left, AmountOfSubstance<T> right) => Multiply<Energy<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(MolarEnergy<T> left, AmountOfSubstance<T> right) => Multiply<Energy<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarEnthalpy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarEnthalpy.g.cs
index adac4b28..ae79fe74 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarEnthalpy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarEnthalpy.g.cs
@@ -26,34 +26,42 @@ public partial record MolarEnthalpy<T> : PhysicalQuantity<MolarEnthalpy<T>, T>,
 	/// <returns>A new MolarEnthalpy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MolarEnthalpy<T> FromJoulePerMole(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new MolarEnthalpy from a value in KilojoulePerMole.
 	/// </summary>
 	/// <param name="value">The value in KilojoulePerMole.</param>
 	/// <returns>A new MolarEnthalpy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MolarEnthalpy<T> FromKilojoulePerMole(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilojoulePerMoleToJoulePerMole)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new MolarEnthalpy from a value in CaloriePerMole.
 	/// </summary>
 	/// <param name="value">The value in CaloriePerMole.</param>
 	/// <returns>A new MolarEnthalpy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MolarEnthalpy<T> FromCaloriePerMole(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.CaloriePerMoleToJoulePerMole)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-MolarEnergy unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IMolarEnergyUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to MolarEnergy.</summary>
+
+	/// <summary>Implicit conversion to MolarEnergy.</summary>
 	public static implicit operator MolarEnergy<T>(MolarEnthalpy<T> value) => MolarEnergy<T>.Create(value.Value);
-/// <summary>Explicit conversion from MolarEnergy.</summary>
+
+	/// <summary>Explicit conversion from MolarEnergy.</summary>
 	public static explicit operator MolarEnthalpy<T>(MolarEnergy<T> value) => Create(value.Value);
-/// <summary>Creates a MolarEnthalpy from a MolarEnergy value.</summary>
+
+	/// <summary>Creates a MolarEnthalpy from a MolarEnergy value.</summary>
 	public static MolarEnthalpy<T> From(MolarEnergy<T> value) => Create(value.Value);
-/// <summary>Subtracts two MolarEnthalpy values, returning the absolute difference as a non-negative MolarEnthalpy.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MolarEnthalpy<T> operator -(MolarEnthalpy<T> left, MolarEnthalpy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two MolarEnthalpy values, returning the absolute difference as a non-negative MolarEnthalpy.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MolarEnthalpy<T> operator -(MolarEnthalpy<T> left, MolarEnthalpy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarMass.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarMass.g.cs
index 4326142a..37ad7236 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarMass.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarMass.g.cs
@@ -25,35 +25,42 @@ public partial record MolarMass<T> : PhysicalQuantity<MolarMass<T>, T>, IVector0
 	/// <returns>A new <see cref="MolarMass{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MolarMass<T> FromKilogramPerMole(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="MolarMass{T}"/> from a value in GramPerMole.
 	/// </summary>
 	/// <param name="value">The value in GramPerMole.</param>
 	/// <returns>A new <see cref="MolarMass{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MolarMass<T> FromGramPerMole(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GramPerMoleToKilogramPerMole)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="MolarMass{T}"/> from a value in Dalton.
 	/// </summary>
 	/// <param name="value">The value in Dalton.</param>
 	/// <returns>A new <see cref="MolarMass{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MolarMass<T> FromDalton(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GramPerMoleToKilogramPerMole)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-MolarMass unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IMolarMassUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two MolarMass values, returning the absolute difference as a non-negative MolarMass.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MolarMass<T> operator -(MolarMass<T> left, MolarMass<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MolarMass<T> operator -(MolarMass<T> left, MolarMass<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies MolarMass by AmountOfSubstance to produce Mass.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Mass<T> operator *(MolarMass<T> left, AmountOfSubstance<T> right) => Multiply<Mass<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator *(MolarMass<T> left, AmountOfSubstance<T> right) => Multiply<Mass<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MomentOfInertia.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MomentOfInertia.g.cs
index daca3bea..33c28c24 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MomentOfInertia.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MomentOfInertia.g.cs
@@ -25,25 +25,32 @@ public partial record MomentOfInertia<T> : PhysicalQuantity<MomentOfInertia<T>,
 	/// <returns>A new <see cref="MomentOfInertia{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MomentOfInertia<T> FromKilogramMeterSquared(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-MomentOfInertia unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IMomentOfInertiaUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two MomentOfInertia values, returning the absolute difference as a non-negative MomentOfInertia.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MomentOfInertia<T> operator -(MomentOfInertia<T> left, MomentOfInertia<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentOfInertia<T> operator -(MomentOfInertia<T> left, MomentOfInertia<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies MomentOfInertia by AngularSpeed to produce AngularMomentumMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularMomentumMagnitude<T> operator *(MomentOfInertia<T> left, AngularSpeed<T> right) => Multiply<AngularMomentumMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentumMagnitude<T> operator *(MomentOfInertia<T> left, AngularSpeed<T> right) => Multiply<AngularMomentumMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies MomentOfInertia by AngularAccelerationMagnitude to produce TorqueMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static TorqueMagnitude<T> operator *(MomentOfInertia<T> left, AngularAccelerationMagnitude<T> right) => Multiply<TorqueMagnitude<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static TorqueMagnitude<T> operator *(MomentOfInertia<T> left, AngularAccelerationMagnitude<T> right) => Multiply<TorqueMagnitude<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum1D.g.cs
index 0a41346b..1958483c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum1D.g.cs
@@ -24,21 +24,25 @@ public partial record Momentum1D<T> : PhysicalQuantity<Momentum1D<T>, T>, IVecto
 	/// <param name="value">The value in NewtonSecond.</param>
 	/// <returns>A new <see cref="Momentum1D{T}"/> instance.</returns>
 	public static Momentum1D<T> FromNewtonSecond(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Momentum unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IMomentumUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="MomentumMagnitude{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public MomentumMagnitude<T> Magnitude() => MomentumMagnitude<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Divides Momentum1D by Duration to produce Force1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Force1D<T> operator /(Momentum1D<T> left, Duration<T> right) => Divide<Force1D<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Force1D<T> operator /(Momentum1D<T> left, Duration<T> right) => Divide<Force1D<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MomentumMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MomentumMagnitude.g.cs
index 04e1187f..59c69108 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MomentumMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MomentumMagnitude.g.cs
@@ -25,33 +25,44 @@ public partial record MomentumMagnitude<T> : PhysicalQuantity<MomentumMagnitude<
 	/// <returns>A new <see cref="MomentumMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static MomentumMagnitude<T> FromNewtonSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Momentum unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IMomentumUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two MomentumMagnitude values, returning the absolute difference as a non-negative MomentumMagnitude.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MomentumMagnitude<T> operator -(MomentumMagnitude<T> left, MomentumMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator -(MomentumMagnitude<T> left, MomentumMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Divides MomentumMagnitude by Speed to produce Mass.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Mass<T> operator /(MomentumMagnitude<T> left, Speed<T> right) => Divide<Mass<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator /(MomentumMagnitude<T> left, Speed<T> right) => Divide<Mass<T>>(left, right);
+
+	/// <summary>
 	/// Divides MomentumMagnitude by Mass to produce Speed.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Speed<T> operator /(MomentumMagnitude<T> left, Mass<T> right) => Divide<Speed<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator /(MomentumMagnitude<T> left, Mass<T> right) => Divide<Speed<T>>(left, right);
+
+	/// <summary>
 	/// Divides MomentumMagnitude by Duration to produce ForceMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ForceMagnitude<T> operator /(MomentumMagnitude<T> left, Duration<T> right) => Divide<ForceMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator /(MomentumMagnitude<T> left, Duration<T> right) => Divide<ForceMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides MomentumMagnitude by ForceMagnitude to produce Duration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Duration<T> operator /(MomentumMagnitude<T> left, ForceMagnitude<T> right) => Divide<Duration<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(MomentumMagnitude<T> left, ForceMagnitude<T> right) => Divide<Duration<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NoiseReductionCoefficient.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NoiseReductionCoefficient.g.cs
index a1ee0d31..69f67dbb 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NoiseReductionCoefficient.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NoiseReductionCoefficient.g.cs
@@ -26,83 +26,98 @@ public partial record NoiseReductionCoefficient<T> : PhysicalQuantity<NoiseReduc
 	/// <returns>A new NoiseReductionCoefficient instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static NoiseReductionCoefficient<T> FromDimensionless(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new NoiseReductionCoefficient from a value in Radian.
 	/// </summary>
 	/// <param name="value">The value in Radian.</param>
 	/// <returns>A new NoiseReductionCoefficient instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static NoiseReductionCoefficient<T> FromRadian(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new NoiseReductionCoefficient from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new NoiseReductionCoefficient instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static NoiseReductionCoefficient<T> FromDegree(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new NoiseReductionCoefficient from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new NoiseReductionCoefficient instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static NoiseReductionCoefficient<T> FromGradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new NoiseReductionCoefficient from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new NoiseReductionCoefficient instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static NoiseReductionCoefficient<T> FromRevolution(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new NoiseReductionCoefficient from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new NoiseReductionCoefficient instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static NoiseReductionCoefficient<T> FromMilliradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new NoiseReductionCoefficient from a value in Percent.
 	/// </summary>
 	/// <param name="value">The value in Percent.</param>
 	/// <returns>A new NoiseReductionCoefficient instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static NoiseReductionCoefficient<T> FromPercent(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new NoiseReductionCoefficient from a value in PartPerMillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerMillion.</param>
 	/// <returns>A new NoiseReductionCoefficient instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static NoiseReductionCoefficient<T> FromPartPerMillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerMillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new NoiseReductionCoefficient from a value in PartPerBillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerBillion.</param>
 	/// <returns>A new NoiseReductionCoefficient instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static NoiseReductionCoefficient<T> FromPartPerBillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerBillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new NoiseReductionCoefficient from a value in PercentByWeight.
 	/// </summary>
 	/// <param name="value">The value in PercentByWeight.</param>
 	/// <returns>A new NoiseReductionCoefficient instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static NoiseReductionCoefficient<T> FromPercentByWeight(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentByWeightToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Dimensionless unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IDimensionlessUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Ratio.</summary>
+
+	/// <summary>Implicit conversion to Ratio.</summary>
 	public static implicit operator Ratio<T>(NoiseReductionCoefficient<T> value) => Ratio<T>.Create(value.Value);
-/// <summary>Explicit conversion from Ratio.</summary>
+
+	/// <summary>Explicit conversion from Ratio.</summary>
 	public static explicit operator NoiseReductionCoefficient<T>(Ratio<T> value) => Create(value.Value);
-/// <summary>Creates a NoiseReductionCoefficient from a Ratio value.</summary>
+
+	/// <summary>Creates a NoiseReductionCoefficient from a Ratio value.</summary>
 	public static NoiseReductionCoefficient<T> From(Ratio<T> value) => Create(value.Value);
-/// <summary>Subtracts two NoiseReductionCoefficient values, returning the absolute difference as a non-negative NoiseReductionCoefficient.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static NoiseReductionCoefficient<T> operator -(NoiseReductionCoefficient<T> left, NoiseReductionCoefficient<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two NoiseReductionCoefficient values, returning the absolute difference as a non-negative NoiseReductionCoefficient.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static NoiseReductionCoefficient<T> operator -(NoiseReductionCoefficient<T> left, NoiseReductionCoefficient<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NormalForce.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NormalForce.g.cs
index b30c56bc..e5807f1a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NormalForce.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NormalForce.g.cs
@@ -26,41 +26,50 @@ public partial record NormalForce<T> : PhysicalQuantity<NormalForce<T>, T>, IVec
 	/// <returns>A new NormalForce instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static NormalForce<T> FromNewton(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new NormalForce from a value in Kilonewton.
 	/// </summary>
 	/// <param name="value">The value in Kilonewton.</param>
 	/// <returns>A new NormalForce instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static NormalForce<T> FromKilonewton(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new NormalForce from a value in Dyne.
 	/// </summary>
 	/// <param name="value">The value in Dyne.</param>
 	/// <returns>A new NormalForce instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static NormalForce<T> FromDyne(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DyneToNewtons)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new NormalForce from a value in PoundForce.
 	/// </summary>
 	/// <param name="value">The value in PoundForce.</param>
 	/// <returns>A new NormalForce instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static NormalForce<T> FromPoundForce(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PoundForceToNewtons)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Force unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IForceUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to ForceMagnitude.</summary>
+
+	/// <summary>Implicit conversion to ForceMagnitude.</summary>
 	public static implicit operator ForceMagnitude<T>(NormalForce<T> value) => ForceMagnitude<T>.Create(value.Value);
-/// <summary>Explicit conversion from ForceMagnitude.</summary>
+
+	/// <summary>Explicit conversion from ForceMagnitude.</summary>
 	public static explicit operator NormalForce<T>(ForceMagnitude<T> value) => Create(value.Value);
-/// <summary>Creates a NormalForce from a ForceMagnitude value.</summary>
+
+	/// <summary>Creates a NormalForce from a ForceMagnitude value.</summary>
 	public static NormalForce<T> From(ForceMagnitude<T> value) => Create(value.Value);
-/// <summary>Subtracts two NormalForce values, returning the absolute difference as a non-negative NormalForce.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static NormalForce<T> operator -(NormalForce<T> left, NormalForce<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two NormalForce values, returning the absolute difference as a non-negative NormalForce.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static NormalForce<T> operator -(NormalForce<T> left, NormalForce<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NuclearCrossSection.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NuclearCrossSection.g.cs
index 3fafb5bb..d6be05ad 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NuclearCrossSection.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NuclearCrossSection.g.cs
@@ -25,24 +25,28 @@ public partial record NuclearCrossSection<T> : PhysicalQuantity<NuclearCrossSect
 	/// <returns>A new <see cref="NuclearCrossSection{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static NuclearCrossSection<T> FromSquareMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="NuclearCrossSection{T}"/> from a value in Barn.
 	/// </summary>
 	/// <param name="value">The value in Barn.</param>
 	/// <returns>A new <see cref="NuclearCrossSection{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static NuclearCrossSection<T> FromBarn(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.BarnToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-NuclearCrossSection unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.INuclearCrossSectionUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two NuclearCrossSection values, returning the absolute difference as a non-negative NuclearCrossSection.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static NuclearCrossSection<T> operator -(NuclearCrossSection<T> left, NuclearCrossSection<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static NuclearCrossSection<T> operator -(NuclearCrossSection<T> left, NuclearCrossSection<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Offset.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Offset.g.cs
index 960b2a27..5b82fb65 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Offset.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Offset.g.cs
@@ -25,84 +25,99 @@ public partial record Offset<T> : PhysicalQuantity<Offset<T>, T>, IVector1<Offse
 	/// <param name="value">The value in Meter.</param>
 	/// <returns>A new Offset instance.</returns>
 	public static Offset<T> FromMeter(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Offset from a value in Kilometer.
 	/// </summary>
 	/// <param name="value">The value in Kilometer.</param>
 	/// <returns>A new Offset instance.</returns>
 	public static Offset<T> FromKilometer(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Kilo)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Offset from a value in Centimeter.
 	/// </summary>
 	/// <param name="value">The value in Centimeter.</param>
 	/// <returns>A new Offset instance.</returns>
 	public static Offset<T> FromCentimeter(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Centi)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Offset from a value in Millimeter.
 	/// </summary>
 	/// <param name="value">The value in Millimeter.</param>
 	/// <returns>A new Offset instance.</returns>
 	public static Offset<T> FromMillimeter(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Milli)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Offset from a value in Micrometer.
 	/// </summary>
 	/// <param name="value">The value in Micrometer.</param>
 	/// <returns>A new Offset instance.</returns>
 	public static Offset<T> FromMicrometer(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Micro)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Offset from a value in Nanometer.
 	/// </summary>
 	/// <param name="value">The value in Nanometer.</param>
 	/// <returns>A new Offset instance.</returns>
 	public static Offset<T> FromNanometer(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Nano)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Offset from a value in Angstrom.
 	/// </summary>
 	/// <param name="value">The value in Angstrom.</param>
 	/// <returns>A new Offset instance.</returns>
 	public static Offset<T> FromAngstrom(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.AngstromToMeters)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Offset from a value in Foot.
 	/// </summary>
 	/// <param name="value">The value in Foot.</param>
 	/// <returns>A new Offset instance.</returns>
 	public static Offset<T> FromFoot(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.FeetToMeters)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Offset from a value in Inch.
 	/// </summary>
 	/// <param name="value">The value in Inch.</param>
 	/// <returns>A new Offset instance.</returns>
 	public static Offset<T> FromInch(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.InchesToMeters)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Offset from a value in Yard.
 	/// </summary>
 	/// <param name="value">The value in Yard.</param>
 	/// <returns>A new Offset instance.</returns>
 	public static Offset<T> FromYard(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.YardToMeters)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Offset from a value in Mile.
 	/// </summary>
 	/// <param name="value">The value in Mile.</param>
 	/// <returns>A new Offset instance.</returns>
 	public static Offset<T> FromMile(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.MileToMeters)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Offset from a value in NauticalMile.
 	/// </summary>
 	/// <param name="value">The value in NauticalMile.</param>
 	/// <returns>A new Offset instance.</returns>
 	public static Offset<T> FromNauticalMile(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.NauticalMileToMeters)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Length unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Displacement1D.</summary>
+
+	/// <summary>Implicit conversion to Displacement1D.</summary>
 	public static implicit operator Displacement1D<T>(Offset<T> value) => Displacement1D<T>.Create(value.Value);
-/// <summary>Explicit conversion from Displacement1D.</summary>
+
+	/// <summary>Explicit conversion from Displacement1D.</summary>
 	public static explicit operator Offset<T>(Displacement1D<T> value) => Create(value.Value);
-/// <summary>Creates a Offset from a Displacement1D value.</summary>
+
+	/// <summary>Creates a Offset from a Displacement1D value.</summary>
 	public static Offset<T> From(Displacement1D<T> value) => Create(value.Value);
-};
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/OpticalPower.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/OpticalPower.g.cs
index d133f253..6c03357f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/OpticalPower.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/OpticalPower.g.cs
@@ -25,17 +25,20 @@ public partial record OpticalPower<T> : PhysicalQuantity<OpticalPower<T>, T>, IV
 	/// <returns>A new <see cref="OpticalPower{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static OpticalPower<T> FromDiopter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-OpticalPower unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IOpticalPowerUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two OpticalPower values, returning the absolute difference as a non-negative OpticalPower.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static OpticalPower<T> operator -(OpticalPower<T> left, OpticalPower<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static OpticalPower<T> operator -(OpticalPower<T> left, OpticalPower<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Perimeter.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Perimeter.g.cs
index 1fa6e9ad..2942b986 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Perimeter.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Perimeter.g.cs
@@ -26,97 +26,114 @@ public partial record Perimeter<T> : PhysicalQuantity<Perimeter<T>, T>, IVector0
 	/// <returns>A new Perimeter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Perimeter<T> FromMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Perimeter from a value in Kilometer.
 	/// </summary>
 	/// <param name="value">The value in Kilometer.</param>
 	/// <returns>A new Perimeter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Perimeter<T> FromKilometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Perimeter from a value in Centimeter.
 	/// </summary>
 	/// <param name="value">The value in Centimeter.</param>
 	/// <returns>A new Perimeter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Perimeter<T> FromCentimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Centi)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Perimeter from a value in Millimeter.
 	/// </summary>
 	/// <param name="value">The value in Millimeter.</param>
 	/// <returns>A new Perimeter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Perimeter<T> FromMillimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Perimeter from a value in Micrometer.
 	/// </summary>
 	/// <param name="value">The value in Micrometer.</param>
 	/// <returns>A new Perimeter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Perimeter<T> FromMicrometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Perimeter from a value in Nanometer.
 	/// </summary>
 	/// <param name="value">The value in Nanometer.</param>
 	/// <returns>A new Perimeter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Perimeter<T> FromNanometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Perimeter from a value in Angstrom.
 	/// </summary>
 	/// <param name="value">The value in Angstrom.</param>
 	/// <returns>A new Perimeter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Perimeter<T> FromAngstrom(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AngstromToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Perimeter from a value in Foot.
 	/// </summary>
 	/// <param name="value">The value in Foot.</param>
 	/// <returns>A new Perimeter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Perimeter<T> FromFoot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FeetToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Perimeter from a value in Inch.
 	/// </summary>
 	/// <param name="value">The value in Inch.</param>
 	/// <returns>A new Perimeter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Perimeter<T> FromInch(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.InchesToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Perimeter from a value in Yard.
 	/// </summary>
 	/// <param name="value">The value in Yard.</param>
 	/// <returns>A new Perimeter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Perimeter<T> FromYard(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YardToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Perimeter from a value in Mile.
 	/// </summary>
 	/// <param name="value">The value in Mile.</param>
 	/// <returns>A new Perimeter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Perimeter<T> FromMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Perimeter from a value in NauticalMile.
 	/// </summary>
 	/// <param name="value">The value in NauticalMile.</param>
 	/// <returns>A new Perimeter instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Perimeter<T> FromNauticalMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.NauticalMileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Length unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Length.</summary>
+
+	/// <summary>Implicit conversion to Length.</summary>
 	public static implicit operator Length<T>(Perimeter<T> value) => Length<T>.Create(value.Value);
-/// <summary>Explicit conversion from Length.</summary>
+
+	/// <summary>Explicit conversion from Length.</summary>
 	public static explicit operator Perimeter<T>(Length<T> value) => Create(value.Value);
-/// <summary>Creates a Perimeter from a Length value.</summary>
+
+	/// <summary>Creates a Perimeter from a Length value.</summary>
 	public static Perimeter<T> From(Length<T> value) => Create(value.Value);
-/// <summary>Subtracts two Perimeter values, returning the absolute difference as a non-negative Perimeter.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Perimeter<T> operator -(Perimeter<T> left, Perimeter<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Perimeter values, returning the absolute difference as a non-negative Perimeter.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Perimeter<T> operator -(Perimeter<T> left, Perimeter<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Period.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Period.g.cs
index 40fbae52..ac85e8d3 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Period.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Period.g.cs
@@ -26,76 +26,90 @@ public partial record Period<T> : PhysicalQuantity<Period<T>, T>, IVector0<Perio
 	/// <returns>A new Period instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Period<T> FromSecond(T value) => Create(Vector0Guards.EnsurePositive(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Period from a value in Millisecond.
 	/// </summary>
 	/// <param name="value">The value in Millisecond.</param>
 	/// <returns>A new Period instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Period<T> FromMillisecond(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Period from a value in Microsecond.
 	/// </summary>
 	/// <param name="value">The value in Microsecond.</param>
 	/// <returns>A new Period instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Period<T> FromMicrosecond(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Period from a value in Minute.
 	/// </summary>
 	/// <param name="value">The value in Minute.</param>
 	/// <returns>A new Period instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Period<T> FromMinute(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.MinuteToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Period from a value in Hour.
 	/// </summary>
 	/// <param name="value">The value in Hour.</param>
 	/// <returns>A new Period instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Period<T> FromHour(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.HourToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Period from a value in Day.
 	/// </summary>
 	/// <param name="value">The value in Day.</param>
 	/// <returns>A new Period instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Period<T> FromDay(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.DayToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Period from a value in Year.
 	/// </summary>
 	/// <param name="value">The value in Year.</param>
 	/// <returns>A new Period instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Period<T> FromYear(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.YearToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Period from a value in Week.
 	/// </summary>
 	/// <param name="value">The value in Week.</param>
 	/// <returns>A new Period instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Period<T> FromWeek(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.WeekToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Period from a value in Nanosecond.
 	/// </summary>
 	/// <param name="value">The value in Nanosecond.</param>
 	/// <returns>A new Period instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Period<T> FromNanosecond(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Time unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ITimeUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Duration.</summary>
+
+	/// <summary>Implicit conversion to Duration.</summary>
 	public static implicit operator Duration<T>(Period<T> value) => Duration<T>.Create(value.Value);
-/// <summary>Explicit conversion from Duration.</summary>
+
+	/// <summary>Explicit conversion from Duration.</summary>
 	public static explicit operator Period<T>(Duration<T> value) => Create(value.Value);
-/// <summary>Creates a Period from a Duration value.</summary>
+
+	/// <summary>Creates a Period from a Duration value.</summary>
 	public static Period<T> From(Duration<T> value) => Create(value.Value);
-/// <summary>Subtracts two Period values, returning the absolute difference as a non-negative Period.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Period<T> operator -(Period<T> left, Period<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Period values, returning the absolute difference as a non-negative Period.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Period<T> operator -(Period<T> left, Period<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Permittivity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Permittivity.g.cs
index bde2ae6f..5adc8675 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Permittivity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Permittivity.g.cs
@@ -25,17 +25,20 @@ public partial record Permittivity<T> : PhysicalQuantity<Permittivity<T>, T>, IV
 	/// <returns>A new <see cref="Permittivity{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Permittivity<T> FromFaradPerMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Permittivity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IPermittivityUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Permittivity values, returning the absolute difference as a non-negative Permittivity.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Permittivity<T> operator -(Permittivity<T> left, Permittivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Permittivity<T> operator -(Permittivity<T> left, Permittivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Phase.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Phase.g.cs
index 3e5bfeb0..fb50e237 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Phase.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Phase.g.cs
@@ -25,42 +25,50 @@ public partial record Phase<T> : PhysicalQuantity<Phase<T>, T>, IVector1<Phase<T
 	/// <param name="value">The value in Radian.</param>
 	/// <returns>A new Phase instance.</returns>
 	public static Phase<T> FromRadian(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Phase from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new Phase instance.</returns>
 	public static Phase<T> FromDegree(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Phase from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new Phase instance.</returns>
 	public static Phase<T> FromGradian(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Phase from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new Phase instance.</returns>
 	public static Phase<T> FromRevolution(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Phase from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new Phase instance.</returns>
 	public static Phase<T> FromMilliradian(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Milli)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AngularDisplacement unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAngularDisplacementUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to SignedAngle.</summary>
+
+	/// <summary>Implicit conversion to SignedAngle.</summary>
 	public static implicit operator SignedAngle<T>(Phase<T> value) => SignedAngle<T>.Create(value.Value);
-/// <summary>Explicit conversion from SignedAngle.</summary>
+
+	/// <summary>Explicit conversion from SignedAngle.</summary>
 	public static explicit operator Phase<T>(SignedAngle<T> value) => Create(value.Value);
-/// <summary>Creates a Phase from a SignedAngle value.</summary>
+
+	/// <summary>Creates a Phase from a SignedAngle value.</summary>
 	public static Phase<T> From(SignedAngle<T> value) => Create(value.Value);
-};
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/PhaseVelocity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/PhaseVelocity.g.cs
index 1140122b..c79a8de6 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/PhaseVelocity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/PhaseVelocity.g.cs
@@ -26,48 +26,58 @@ public partial record PhaseVelocity<T> : PhysicalQuantity<PhaseVelocity<T>, T>,
 	/// <returns>A new PhaseVelocity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static PhaseVelocity<T> FromMeterPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new PhaseVelocity from a value in KilometerPerHour.
 	/// </summary>
 	/// <param name="value">The value in KilometerPerHour.</param>
 	/// <returns>A new PhaseVelocity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static PhaseVelocity<T> FromKilometerPerHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilometerPerHourToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new PhaseVelocity from a value in MilePerHour.
 	/// </summary>
 	/// <param name="value">The value in MilePerHour.</param>
 	/// <returns>A new PhaseVelocity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static PhaseVelocity<T> FromMilePerHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MilePerHourToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new PhaseVelocity from a value in FootPerSecond.
 	/// </summary>
 	/// <param name="value">The value in FootPerSecond.</param>
 	/// <returns>A new PhaseVelocity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static PhaseVelocity<T> FromFootPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FootPerSecondToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new PhaseVelocity from a value in Knot.
 	/// </summary>
 	/// <param name="value">The value in Knot.</param>
 	/// <returns>A new PhaseVelocity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static PhaseVelocity<T> FromKnot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KnotToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Velocity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IVelocityUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Speed.</summary>
+
+	/// <summary>Implicit conversion to Speed.</summary>
 	public static implicit operator Speed<T>(PhaseVelocity<T> value) => Speed<T>.Create(value.Value);
-/// <summary>Explicit conversion from Speed.</summary>
+
+	/// <summary>Explicit conversion from Speed.</summary>
 	public static explicit operator PhaseVelocity<T>(Speed<T> value) => Create(value.Value);
-/// <summary>Creates a PhaseVelocity from a Speed value.</summary>
+
+	/// <summary>Creates a PhaseVelocity from a Speed value.</summary>
 	public static PhaseVelocity<T> From(Speed<T> value) => Create(value.Value);
-/// <summary>Subtracts two PhaseVelocity values, returning the absolute difference as a non-negative PhaseVelocity.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static PhaseVelocity<T> operator -(PhaseVelocity<T> left, PhaseVelocity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two PhaseVelocity values, returning the absolute difference as a non-negative PhaseVelocity.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static PhaseVelocity<T> operator -(PhaseVelocity<T> left, PhaseVelocity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Pitch.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Pitch.g.cs
index ec2d344e..e62b5832 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Pitch.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Pitch.g.cs
@@ -26,34 +26,42 @@ public partial record Pitch<T> : PhysicalQuantity<Pitch<T>, T>, IVector0<Pitch<T
 	/// <returns>A new Pitch instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Pitch<T> FromHertz(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Pitch from a value in Kilohertz.
 	/// </summary>
 	/// <param name="value">The value in Kilohertz.</param>
 	/// <returns>A new Pitch instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Pitch<T> FromKilohertz(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Pitch from a value in Megahertz.
 	/// </summary>
 	/// <param name="value">The value in Megahertz.</param>
 	/// <returns>A new Pitch instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Pitch<T> FromMegahertz(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Mega)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Frequency unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IFrequencyUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Frequency.</summary>
+
+	/// <summary>Implicit conversion to Frequency.</summary>
 	public static implicit operator Frequency<T>(Pitch<T> value) => Frequency<T>.Create(value.Value);
-/// <summary>Explicit conversion from Frequency.</summary>
+
+	/// <summary>Explicit conversion from Frequency.</summary>
 	public static explicit operator Pitch<T>(Frequency<T> value) => Create(value.Value);
-/// <summary>Creates a Pitch from a Frequency value.</summary>
+
+	/// <summary>Creates a Pitch from a Frequency value.</summary>
 	public static Pitch<T> From(Frequency<T> value) => Create(value.Value);
-/// <summary>Subtracts two Pitch values, returning the absolute difference as a non-negative Pitch.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Pitch<T> operator -(Pitch<T> left, Pitch<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Pitch values, returning the absolute difference as a non-negative Pitch.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pitch<T> operator -(Pitch<T> left, Pitch<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/PotentialEnergy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/PotentialEnergy.g.cs
index ec356fbd..61aa44ba 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/PotentialEnergy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/PotentialEnergy.g.cs
@@ -26,76 +26,90 @@ public partial record PotentialEnergy<T> : PhysicalQuantity<PotentialEnergy<T>,
 	/// <returns>A new PotentialEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static PotentialEnergy<T> FromJoule(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new PotentialEnergy from a value in Kilojoule.
 	/// </summary>
 	/// <param name="value">The value in Kilojoule.</param>
 	/// <returns>A new PotentialEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static PotentialEnergy<T> FromKilojoule(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new PotentialEnergy from a value in ElectronVolt.
 	/// </summary>
 	/// <param name="value">The value in ElectronVolt.</param>
 	/// <returns>A new PotentialEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static PotentialEnergy<T> FromElectronVolt(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.ElectronVoltToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new PotentialEnergy from a value in Calorie.
 	/// </summary>
 	/// <param name="value">The value in Calorie.</param>
 	/// <returns>A new PotentialEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static PotentialEnergy<T> FromCalorie(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.CalorieToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new PotentialEnergy from a value in Kilocalorie.
 	/// </summary>
 	/// <param name="value">The value in Kilocalorie.</param>
 	/// <returns>A new PotentialEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static PotentialEnergy<T> FromKilocalorie(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilocalorieToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new PotentialEnergy from a value in KilowattHour.
 	/// </summary>
 	/// <param name="value">The value in KilowattHour.</param>
 	/// <returns>A new PotentialEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static PotentialEnergy<T> FromKilowattHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilowattHourToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new PotentialEnergy from a value in WattHour.
 	/// </summary>
 	/// <param name="value">The value in WattHour.</param>
 	/// <returns>A new PotentialEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static PotentialEnergy<T> FromWattHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.WattHourToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new PotentialEnergy from a value in Erg.
 	/// </summary>
 	/// <param name="value">The value in Erg.</param>
 	/// <returns>A new PotentialEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static PotentialEnergy<T> FromErg(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.ErgToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new PotentialEnergy from a value in Btu.
 	/// </summary>
 	/// <param name="value">The value in Btu.</param>
 	/// <returns>A new PotentialEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static PotentialEnergy<T> FromBtu(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.BtuToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Energy unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IEnergyUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Energy.</summary>
+
+	/// <summary>Implicit conversion to Energy.</summary>
 	public static implicit operator Energy<T>(PotentialEnergy<T> value) => Energy<T>.Create(value.Value);
-/// <summary>Explicit conversion from Energy.</summary>
+
+	/// <summary>Explicit conversion from Energy.</summary>
 	public static explicit operator PotentialEnergy<T>(Energy<T> value) => Create(value.Value);
-/// <summary>Creates a PotentialEnergy from a Energy value.</summary>
+
+	/// <summary>Creates a PotentialEnergy from a Energy value.</summary>
 	public static PotentialEnergy<T> From(Energy<T> value) => Create(value.Value);
-/// <summary>Subtracts two PotentialEnergy values, returning the absolute difference as a non-negative PotentialEnergy.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static PotentialEnergy<T> operator -(PotentialEnergy<T> left, PotentialEnergy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two PotentialEnergy values, returning the absolute difference as a non-negative PotentialEnergy.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static PotentialEnergy<T> operator -(PotentialEnergy<T> left, PotentialEnergy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Power.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Power.g.cs
index 16bfd485..0671b1be 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Power.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Power.g.cs
@@ -25,74 +25,98 @@ public partial record Power<T> : PhysicalQuantity<Power<T>, T>, IVector0<Power<T
 	/// <returns>A new <see cref="Power{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Power<T> FromWatt(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Power{T}"/> from a value in Kilowatt.
 	/// </summary>
 	/// <param name="value">The value in Kilowatt.</param>
 	/// <returns>A new <see cref="Power{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Power<T> FromKilowatt(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Power{T}"/> from a value in Megawatt.
 	/// </summary>
 	/// <param name="value">The value in Megawatt.</param>
 	/// <returns>A new <see cref="Power{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Power<T> FromMegawatt(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Mega)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Power{T}"/> from a value in Horsepower.
 	/// </summary>
 	/// <param name="value">The value in Horsepower.</param>
 	/// <returns>A new <see cref="Power{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Power<T> FromHorsepower(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.HorsepowerToWatts)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Power unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IPowerUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Power values, returning the absolute difference as a non-negative Power.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Power<T> operator -(Power<T> left, Power<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator -(Power<T> left, Power<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Divides Power by VoltageMagnitude to produce CurrentMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static CurrentMagnitude<T> operator /(Power<T> left, VoltageMagnitude<T> right) => Divide<CurrentMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static CurrentMagnitude<T> operator /(Power<T> left, VoltageMagnitude<T> right) => Divide<CurrentMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides Power by CurrentMagnitude to produce VoltageMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static VoltageMagnitude<T> operator /(Power<T> left, CurrentMagnitude<T> right) => Divide<VoltageMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator /(Power<T> left, CurrentMagnitude<T> right) => Divide<VoltageMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides Power by Speed to produce ForceMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ForceMagnitude<T> operator /(Power<T> left, Speed<T> right) => Divide<ForceMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator /(Power<T> left, Speed<T> right) => Divide<ForceMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides Power by ForceMagnitude to produce Speed.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Speed<T> operator /(Power<T> left, ForceMagnitude<T> right) => Divide<Speed<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator /(Power<T> left, ForceMagnitude<T> right) => Divide<Speed<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Power by Duration to produce Energy.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Energy<T> operator *(Power<T> left, Duration<T> right) => Multiply<Energy<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Power<T> left, Duration<T> right) => Multiply<Energy<T>>(left, right);
+
+	/// <summary>
 	/// Divides Power by Area to produce Irradiance.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Irradiance<T> operator /(Power<T> left, Area<T> right) => Divide<Irradiance<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Irradiance<T> operator /(Power<T> left, Area<T> right) => Divide<Irradiance<T>>(left, right);
+
+	/// <summary>
 	/// Divides Power by Irradiance to produce Area.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Area<T> operator /(Power<T> left, Irradiance<T> right) => Divide<Area<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator /(Power<T> left, Irradiance<T> right) => Divide<Area<T>>(left, right);
+
+	/// <summary>
 	/// Divides Power by Volume to produce ElectricPowerDensity.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ElectricPowerDensity<T> operator /(Power<T> left, Volume<T> right) => Divide<ElectricPowerDensity<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ElectricPowerDensity<T> operator /(Power<T> left, Volume<T> right) => Divide<ElectricPowerDensity<T>>(left, right);
+
+	/// <summary>
 	/// Divides Power by ElectricPowerDensity to produce Volume.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Volume<T> operator /(Power<T> left, ElectricPowerDensity<T> right) => Divide<Volume<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator /(Power<T> left, ElectricPowerDensity<T> right) => Divide<Volume<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Pressure.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Pressure.g.cs
index 25b1802e..a5c7c9ef 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Pressure.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Pressure.g.cs
@@ -25,64 +25,78 @@ public partial record Pressure<T> : PhysicalQuantity<Pressure<T>, T>, IVector0<P
 	/// <returns>A new <see cref="Pressure{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Pressure<T> FromPascal(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Pressure{T}"/> from a value in Kilopascal.
 	/// </summary>
 	/// <param name="value">The value in Kilopascal.</param>
 	/// <returns>A new <see cref="Pressure{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Pressure<T> FromKilopascal(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Pressure{T}"/> from a value in Bar.
 	/// </summary>
 	/// <param name="value">The value in Bar.</param>
 	/// <returns>A new <see cref="Pressure{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Pressure<T> FromBar(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.BarToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Pressure{T}"/> from a value in Atmosphere.
 	/// </summary>
 	/// <param name="value">The value in Atmosphere.</param>
 	/// <returns>A new <see cref="Pressure{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Pressure<T> FromAtmosphere(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AtmosphereToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Pressure{T}"/> from a value in Psi.
 	/// </summary>
 	/// <param name="value">The value in Psi.</param>
 	/// <returns>A new <see cref="Pressure{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Pressure<T> FromPsi(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PsiToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Pressure{T}"/> from a value in Torr.
 	/// </summary>
 	/// <param name="value">The value in Torr.</param>
 	/// <returns>A new <see cref="Pressure{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Pressure<T> FromTorr(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.TorrToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Pressure unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IPressureUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Pressure values, returning the absolute difference as a non-negative Pressure.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Pressure<T> operator -(Pressure<T> left, Pressure<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator -(Pressure<T> left, Pressure<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Pressure by Area to produce ForceMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ForceMagnitude<T> operator *(Pressure<T> left, Area<T> right) => Multiply<ForceMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(Pressure<T> left, Area<T> right) => Multiply<ForceMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Pressure by Volume to produce Energy.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Energy<T> operator *(Pressure<T> left, Volume<T> right) => Multiply<Energy<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Pressure<T> left, Volume<T> right) => Multiply<Energy<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Pressure by Sensitivity to produce VoltageMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static VoltageMagnitude<T> operator *(Pressure<T> left, Sensitivity<T> right) => Multiply<VoltageMagnitude<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(Pressure<T> left, Sensitivity<T> right) => Multiply<VoltageMagnitude<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RadioactiveActivity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RadioactiveActivity.g.cs
index 5c849f00..8f16d6c1 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RadioactiveActivity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RadioactiveActivity.g.cs
@@ -25,24 +25,28 @@ public partial record RadioactiveActivity<T> : PhysicalQuantity<RadioactiveActiv
 	/// <returns>A new <see cref="RadioactiveActivity{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static RadioactiveActivity<T> FromBecquerel(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="RadioactiveActivity{T}"/> from a value in Curie.
 	/// </summary>
 	/// <param name="value">The value in Curie.</param>
 	/// <returns>A new <see cref="RadioactiveActivity{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static RadioactiveActivity<T> FromCurie(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.CurieToBecquerels)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-RadioactiveActivity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IRadioactiveActivityUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two RadioactiveActivity values, returning the absolute difference as a non-negative RadioactiveActivity.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static RadioactiveActivity<T> operator -(RadioactiveActivity<T> left, RadioactiveActivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static RadioactiveActivity<T> operator -(RadioactiveActivity<T> left, RadioactiveActivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Radius.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Radius.g.cs
index b46605fe..7e275f30 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Radius.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Radius.g.cs
@@ -26,97 +26,114 @@ public partial record Radius<T> : PhysicalQuantity<Radius<T>, T>, IVector0<Radiu
 	/// <returns>A new Radius instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Radius<T> FromMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Radius from a value in Kilometer.
 	/// </summary>
 	/// <param name="value">The value in Kilometer.</param>
 	/// <returns>A new Radius instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Radius<T> FromKilometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Radius from a value in Centimeter.
 	/// </summary>
 	/// <param name="value">The value in Centimeter.</param>
 	/// <returns>A new Radius instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Radius<T> FromCentimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Centi)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Radius from a value in Millimeter.
 	/// </summary>
 	/// <param name="value">The value in Millimeter.</param>
 	/// <returns>A new Radius instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Radius<T> FromMillimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Radius from a value in Micrometer.
 	/// </summary>
 	/// <param name="value">The value in Micrometer.</param>
 	/// <returns>A new Radius instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Radius<T> FromMicrometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Radius from a value in Nanometer.
 	/// </summary>
 	/// <param name="value">The value in Nanometer.</param>
 	/// <returns>A new Radius instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Radius<T> FromNanometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Radius from a value in Angstrom.
 	/// </summary>
 	/// <param name="value">The value in Angstrom.</param>
 	/// <returns>A new Radius instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Radius<T> FromAngstrom(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AngstromToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Radius from a value in Foot.
 	/// </summary>
 	/// <param name="value">The value in Foot.</param>
 	/// <returns>A new Radius instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Radius<T> FromFoot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FeetToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Radius from a value in Inch.
 	/// </summary>
 	/// <param name="value">The value in Inch.</param>
 	/// <returns>A new Radius instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Radius<T> FromInch(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.InchesToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Radius from a value in Yard.
 	/// </summary>
 	/// <param name="value">The value in Yard.</param>
 	/// <returns>A new Radius instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Radius<T> FromYard(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YardToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Radius from a value in Mile.
 	/// </summary>
 	/// <param name="value">The value in Mile.</param>
 	/// <returns>A new Radius instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Radius<T> FromMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Radius from a value in NauticalMile.
 	/// </summary>
 	/// <param name="value">The value in NauticalMile.</param>
 	/// <returns>A new Radius instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Radius<T> FromNauticalMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.NauticalMileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Length unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Length.</summary>
+
+	/// <summary>Implicit conversion to Length.</summary>
 	public static implicit operator Length<T>(Radius<T> value) => Length<T>.Create(value.Value);
-/// <summary>Explicit conversion from Length.</summary>
+
+	/// <summary>Explicit conversion from Length.</summary>
 	public static explicit operator Radius<T>(Length<T> value) => Create(value.Value);
-/// <summary>Creates a Radius from a Length value.</summary>
+
+	/// <summary>Creates a Radius from a Length value.</summary>
 	public static Radius<T> From(Length<T> value) => Create(value.Value);
-/// <summary>Subtracts two Radius values, returning the absolute difference as a non-negative Radius.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Radius<T> operator -(Radius<T> left, Radius<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Radius values, returning the absolute difference as a non-negative Radius.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Radius<T> operator -(Radius<T> left, Radius<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RateConstant.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RateConstant.g.cs
index 420862f0..80c8ac7a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RateConstant.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RateConstant.g.cs
@@ -25,17 +25,20 @@ public partial record RateConstant<T> : PhysicalQuantity<RateConstant<T>, T>, IV
 	/// <returns>A new <see cref="RateConstant{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static RateConstant<T> FromPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-RateConstant unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IRateConstantUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two RateConstant values, returning the absolute difference as a non-negative RateConstant.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static RateConstant<T> operator -(RateConstant<T> left, RateConstant<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static RateConstant<T> operator -(RateConstant<T> left, RateConstant<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Ratio.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Ratio.g.cs
index 0826131d..df50e427 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Ratio.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Ratio.g.cs
@@ -25,104 +25,128 @@ public partial record Ratio<T> : PhysicalQuantity<Ratio<T>, T>, IVector0<Ratio<T
 	/// <returns>A new <see cref="Ratio{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Ratio<T> FromDimensionless(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Ratio{T}"/> from a value in Radian.
 	/// </summary>
 	/// <param name="value">The value in Radian.</param>
 	/// <returns>A new <see cref="Ratio{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Ratio<T> FromRadian(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Ratio{T}"/> from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new <see cref="Ratio{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Ratio<T> FromDegree(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Ratio{T}"/> from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new <see cref="Ratio{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Ratio<T> FromGradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Ratio{T}"/> from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new <see cref="Ratio{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Ratio<T> FromRevolution(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Ratio{T}"/> from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new <see cref="Ratio{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Ratio<T> FromMilliradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Ratio{T}"/> from a value in Percent.
 	/// </summary>
 	/// <param name="value">The value in Percent.</param>
 	/// <returns>A new <see cref="Ratio{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Ratio<T> FromPercent(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Ratio{T}"/> from a value in PartPerMillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerMillion.</param>
 	/// <returns>A new <see cref="Ratio{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Ratio<T> FromPartPerMillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerMillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Ratio{T}"/> from a value in PartPerBillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerBillion.</param>
 	/// <returns>A new <see cref="Ratio{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Ratio<T> FromPartPerBillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerBillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Ratio{T}"/> from a value in PercentByWeight.
 	/// </summary>
 	/// <param name="value">The value in PercentByWeight.</param>
 	/// <returns>A new <see cref="Ratio{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Ratio<T> FromPercentByWeight(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentByWeightToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Dimensionless unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IDimensionlessUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Ratio values, returning the absolute difference as a non-negative Ratio.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Ratio<T> operator -(Ratio<T> left, Ratio<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator -(Ratio<T> left, Ratio<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Ratio by Ratio to produce Ratio.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Ratio<T> operator *(Ratio<T> left, Ratio<T> right) => Multiply<Ratio<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(Ratio<T> left, Ratio<T> right) => Multiply<Ratio<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Ratio by SignedRatio to produce SignedRatio.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SignedRatio<T> operator *(Ratio<T> left, SignedRatio<T> right) => Multiply<SignedRatio<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedRatio<T> operator *(Ratio<T> left, SignedRatio<T> right) => Multiply<SignedRatio<T>>(left, right);
+
+	/// <summary>
 	/// Divides Ratio by Duration to produce Frequency.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Frequency<T> operator /(Ratio<T> left, Duration<T> right) => Divide<Frequency<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator /(Ratio<T> left, Duration<T> right) => Divide<Frequency<T>>(left, right);
+
+	/// <summary>
 	/// Divides Ratio by Frequency to produce Duration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Duration<T> operator /(Ratio<T> left, Frequency<T> right) => Divide<Duration<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Ratio<T> left, Frequency<T> right) => Divide<Duration<T>>(left, right);
+
+	/// <summary>
 	/// Divides Ratio by Temperature to produce ThermalExpansionCoefficient.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ThermalExpansionCoefficient<T> operator /(Ratio<T> left, Temperature<T> right) => Divide<ThermalExpansionCoefficient<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ThermalExpansionCoefficient<T> operator /(Ratio<T> left, Temperature<T> right) => Divide<ThermalExpansionCoefficient<T>>(left, right);
+
+	/// <summary>
 	/// Divides Ratio by ThermalExpansionCoefficient to produce Temperature.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Temperature<T> operator /(Ratio<T> left, ThermalExpansionCoefficient<T> right) => Divide<Temperature<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Temperature<T> operator /(Ratio<T> left, ThermalExpansionCoefficient<T> right) => Divide<Temperature<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReactionRate.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReactionRate.g.cs
index a9704045..5687e7e2 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReactionRate.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReactionRate.g.cs
@@ -25,21 +25,26 @@ public partial record ReactionRate<T> : PhysicalQuantity<ReactionRate<T>, T>, IV
 	/// <returns>A new <see cref="ReactionRate{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReactionRate<T> FromMolePerCubicMeterSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ReactionRate unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IReactionRateUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two ReactionRate values, returning the absolute difference as a non-negative ReactionRate.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ReactionRate<T> operator -(ReactionRate<T> left, ReactionRate<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ReactionRate<T> operator -(ReactionRate<T> left, ReactionRate<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies ReactionRate by Duration to produce Concentration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Concentration<T> operator *(ReactionRate<T> left, Duration<T> right) => Multiply<Concentration<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Concentration<T> operator *(ReactionRate<T> left, Duration<T> right) => Multiply<Concentration<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReflectionCoefficient.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReflectionCoefficient.g.cs
index 8a759c75..346d04b6 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReflectionCoefficient.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReflectionCoefficient.g.cs
@@ -25,72 +25,85 @@ public partial record ReflectionCoefficient<T> : PhysicalQuantity<ReflectionCoef
 	/// <param name="value">The value in Dimensionless.</param>
 	/// <returns>A new ReflectionCoefficient instance.</returns>
 	public static ReflectionCoefficient<T> FromDimensionless(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReflectionCoefficient from a value in Radian.
 	/// </summary>
 	/// <param name="value">The value in Radian.</param>
 	/// <returns>A new ReflectionCoefficient instance.</returns>
 	public static ReflectionCoefficient<T> FromRadian(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReflectionCoefficient from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new ReflectionCoefficient instance.</returns>
 	public static ReflectionCoefficient<T> FromDegree(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReflectionCoefficient from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new ReflectionCoefficient instance.</returns>
 	public static ReflectionCoefficient<T> FromGradian(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReflectionCoefficient from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new ReflectionCoefficient instance.</returns>
 	public static ReflectionCoefficient<T> FromRevolution(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReflectionCoefficient from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new ReflectionCoefficient instance.</returns>
 	public static ReflectionCoefficient<T> FromMilliradian(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Milli)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReflectionCoefficient from a value in Percent.
 	/// </summary>
 	/// <param name="value">The value in Percent.</param>
 	/// <returns>A new ReflectionCoefficient instance.</returns>
 	public static ReflectionCoefficient<T> FromPercent(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.PercentToRatio)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReflectionCoefficient from a value in PartPerMillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerMillion.</param>
 	/// <returns>A new ReflectionCoefficient instance.</returns>
 	public static ReflectionCoefficient<T> FromPartPerMillion(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.PartPerMillionToRatio)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReflectionCoefficient from a value in PartPerBillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerBillion.</param>
 	/// <returns>A new ReflectionCoefficient instance.</returns>
 	public static ReflectionCoefficient<T> FromPartPerBillion(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.PartPerBillionToRatio)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReflectionCoefficient from a value in PercentByWeight.
 	/// </summary>
 	/// <param name="value">The value in PercentByWeight.</param>
 	/// <returns>A new ReflectionCoefficient instance.</returns>
 	public static ReflectionCoefficient<T> FromPercentByWeight(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.PercentByWeightToRatio)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Dimensionless unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IDimensionlessUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to SignedRatio.</summary>
+
+	/// <summary>Implicit conversion to SignedRatio.</summary>
 	public static implicit operator SignedRatio<T>(ReflectionCoefficient<T> value) => SignedRatio<T>.Create(value.Value);
-/// <summary>Explicit conversion from SignedRatio.</summary>
+
+	/// <summary>Explicit conversion from SignedRatio.</summary>
 	public static explicit operator ReflectionCoefficient<T>(SignedRatio<T> value) => Create(value.Value);
-/// <summary>Creates a ReflectionCoefficient from a SignedRatio value.</summary>
+
+	/// <summary>Creates a ReflectionCoefficient from a SignedRatio value.</summary>
 	public static ReflectionCoefficient<T> From(SignedRatio<T> value) => Create(value.Value);
-};
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RefractiveIndex.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RefractiveIndex.g.cs
index f166a207..976c0980 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RefractiveIndex.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RefractiveIndex.g.cs
@@ -26,83 +26,98 @@ public partial record RefractiveIndex<T> : PhysicalQuantity<RefractiveIndex<T>,
 	/// <returns>A new RefractiveIndex instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static RefractiveIndex<T> FromDimensionless(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new RefractiveIndex from a value in Radian.
 	/// </summary>
 	/// <param name="value">The value in Radian.</param>
 	/// <returns>A new RefractiveIndex instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static RefractiveIndex<T> FromRadian(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new RefractiveIndex from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new RefractiveIndex instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static RefractiveIndex<T> FromDegree(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new RefractiveIndex from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new RefractiveIndex instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static RefractiveIndex<T> FromGradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new RefractiveIndex from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new RefractiveIndex instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static RefractiveIndex<T> FromRevolution(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new RefractiveIndex from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new RefractiveIndex instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static RefractiveIndex<T> FromMilliradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new RefractiveIndex from a value in Percent.
 	/// </summary>
 	/// <param name="value">The value in Percent.</param>
 	/// <returns>A new RefractiveIndex instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static RefractiveIndex<T> FromPercent(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new RefractiveIndex from a value in PartPerMillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerMillion.</param>
 	/// <returns>A new RefractiveIndex instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static RefractiveIndex<T> FromPartPerMillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerMillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new RefractiveIndex from a value in PartPerBillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerBillion.</param>
 	/// <returns>A new RefractiveIndex instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static RefractiveIndex<T> FromPartPerBillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerBillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new RefractiveIndex from a value in PercentByWeight.
 	/// </summary>
 	/// <param name="value">The value in PercentByWeight.</param>
 	/// <returns>A new RefractiveIndex instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static RefractiveIndex<T> FromPercentByWeight(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentByWeightToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Dimensionless unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IDimensionlessUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Ratio.</summary>
+
+	/// <summary>Implicit conversion to Ratio.</summary>
 	public static implicit operator Ratio<T>(RefractiveIndex<T> value) => Ratio<T>.Create(value.Value);
-/// <summary>Explicit conversion from Ratio.</summary>
+
+	/// <summary>Explicit conversion from Ratio.</summary>
 	public static explicit operator RefractiveIndex<T>(Ratio<T> value) => Create(value.Value);
-/// <summary>Creates a RefractiveIndex from a Ratio value.</summary>
+
+	/// <summary>Creates a RefractiveIndex from a Ratio value.</summary>
 	public static RefractiveIndex<T> From(Ratio<T> value) => Create(value.Value);
-/// <summary>Subtracts two RefractiveIndex values, returning the absolute difference as a non-negative RefractiveIndex.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static RefractiveIndex<T> operator -(RefractiveIndex<T> left, RefractiveIndex<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two RefractiveIndex values, returning the absolute difference as a non-negative RefractiveIndex.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static RefractiveIndex<T> operator -(RefractiveIndex<T> left, RefractiveIndex<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Resistance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Resistance.g.cs
index be356b2a..5dcbe0f4 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Resistance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Resistance.g.cs
@@ -25,39 +25,48 @@ public partial record Resistance<T> : PhysicalQuantity<Resistance<T>, T>, IVecto
 	/// <returns>A new <see cref="Resistance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Resistance<T> FromOhm(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Resistance{T}"/> from a value in Kilohm.
 	/// </summary>
 	/// <param name="value">The value in Kilohm.</param>
 	/// <returns>A new <see cref="Resistance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Resistance<T> FromKilohm(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Resistance{T}"/> from a value in Megohm.
 	/// </summary>
 	/// <param name="value">The value in Megohm.</param>
 	/// <returns>A new <see cref="Resistance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Resistance<T> FromMegohm(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Mega)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricResistance unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricResistanceUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Resistance values, returning the absolute difference as a non-negative Resistance.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Resistance<T> operator -(Resistance<T> left, Resistance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Resistance<T> operator -(Resistance<T> left, Resistance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Resistance by CurrentMagnitude to produce VoltageMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static VoltageMagnitude<T> operator *(Resistance<T> left, CurrentMagnitude<T> right) => Multiply<VoltageMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(Resistance<T> left, CurrentMagnitude<T> right) => Multiply<VoltageMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Resistance by Current1D to produce Voltage.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Voltage<T> operator *(Resistance<T> left, Current1D<T> right) => Multiply<Voltage<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Voltage<T> operator *(Resistance<T> left, Current1D<T> right) => Multiply<Voltage<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReverberationTime.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReverberationTime.g.cs
index daf599c9..9d49783b 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReverberationTime.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReverberationTime.g.cs
@@ -26,76 +26,90 @@ public partial record ReverberationTime<T> : PhysicalQuantity<ReverberationTime<
 	/// <returns>A new ReverberationTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReverberationTime<T> FromSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReverberationTime from a value in Millisecond.
 	/// </summary>
 	/// <param name="value">The value in Millisecond.</param>
 	/// <returns>A new ReverberationTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReverberationTime<T> FromMillisecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReverberationTime from a value in Microsecond.
 	/// </summary>
 	/// <param name="value">The value in Microsecond.</param>
 	/// <returns>A new ReverberationTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReverberationTime<T> FromMicrosecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReverberationTime from a value in Minute.
 	/// </summary>
 	/// <param name="value">The value in Minute.</param>
 	/// <returns>A new ReverberationTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReverberationTime<T> FromMinute(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MinuteToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReverberationTime from a value in Hour.
 	/// </summary>
 	/// <param name="value">The value in Hour.</param>
 	/// <returns>A new ReverberationTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReverberationTime<T> FromHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.HourToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReverberationTime from a value in Day.
 	/// </summary>
 	/// <param name="value">The value in Day.</param>
 	/// <returns>A new ReverberationTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReverberationTime<T> FromDay(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DayToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReverberationTime from a value in Year.
 	/// </summary>
 	/// <param name="value">The value in Year.</param>
 	/// <returns>A new ReverberationTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReverberationTime<T> FromYear(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YearToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReverberationTime from a value in Week.
 	/// </summary>
 	/// <param name="value">The value in Week.</param>
 	/// <returns>A new ReverberationTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReverberationTime<T> FromWeek(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.WeekToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReverberationTime from a value in Nanosecond.
 	/// </summary>
 	/// <param name="value">The value in Nanosecond.</param>
 	/// <returns>A new ReverberationTime instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReverberationTime<T> FromNanosecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Time unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ITimeUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Duration.</summary>
+
+	/// <summary>Implicit conversion to Duration.</summary>
 	public static implicit operator Duration<T>(ReverberationTime<T> value) => Duration<T>.Create(value.Value);
-/// <summary>Explicit conversion from Duration.</summary>
+
+	/// <summary>Explicit conversion from Duration.</summary>
 	public static explicit operator ReverberationTime<T>(Duration<T> value) => Create(value.Value);
-/// <summary>Creates a ReverberationTime from a Duration value.</summary>
+
+	/// <summary>Creates a ReverberationTime from a Duration value.</summary>
 	public static ReverberationTime<T> From(Duration<T> value) => Create(value.Value);
-/// <summary>Subtracts two ReverberationTime values, returning the absolute difference as a non-negative ReverberationTime.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ReverberationTime<T> operator -(ReverberationTime<T> left, ReverberationTime<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two ReverberationTime values, returning the absolute difference as a non-negative ReverberationTime.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ReverberationTime<T> operator -(ReverberationTime<T> left, ReverberationTime<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReynoldsNumber.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReynoldsNumber.g.cs
index c50e610d..e8440c4a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReynoldsNumber.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReynoldsNumber.g.cs
@@ -26,83 +26,98 @@ public partial record ReynoldsNumber<T> : PhysicalQuantity<ReynoldsNumber<T>, T>
 	/// <returns>A new ReynoldsNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReynoldsNumber<T> FromDimensionless(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReynoldsNumber from a value in Radian.
 	/// </summary>
 	/// <param name="value">The value in Radian.</param>
 	/// <returns>A new ReynoldsNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReynoldsNumber<T> FromRadian(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReynoldsNumber from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new ReynoldsNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReynoldsNumber<T> FromDegree(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReynoldsNumber from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new ReynoldsNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReynoldsNumber<T> FromGradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReynoldsNumber from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new ReynoldsNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReynoldsNumber<T> FromRevolution(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReynoldsNumber from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new ReynoldsNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReynoldsNumber<T> FromMilliradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReynoldsNumber from a value in Percent.
 	/// </summary>
 	/// <param name="value">The value in Percent.</param>
 	/// <returns>A new ReynoldsNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReynoldsNumber<T> FromPercent(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReynoldsNumber from a value in PartPerMillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerMillion.</param>
 	/// <returns>A new ReynoldsNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReynoldsNumber<T> FromPartPerMillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerMillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReynoldsNumber from a value in PartPerBillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerBillion.</param>
 	/// <returns>A new ReynoldsNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReynoldsNumber<T> FromPartPerBillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerBillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ReynoldsNumber from a value in PercentByWeight.
 	/// </summary>
 	/// <param name="value">The value in PercentByWeight.</param>
 	/// <returns>A new ReynoldsNumber instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ReynoldsNumber<T> FromPercentByWeight(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentByWeightToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Dimensionless unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IDimensionlessUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Ratio.</summary>
+
+	/// <summary>Implicit conversion to Ratio.</summary>
 	public static implicit operator Ratio<T>(ReynoldsNumber<T> value) => Ratio<T>.Create(value.Value);
-/// <summary>Explicit conversion from Ratio.</summary>
+
+	/// <summary>Explicit conversion from Ratio.</summary>
 	public static explicit operator ReynoldsNumber<T>(Ratio<T> value) => Create(value.Value);
-/// <summary>Creates a ReynoldsNumber from a Ratio value.</summary>
+
+	/// <summary>Creates a ReynoldsNumber from a Ratio value.</summary>
 	public static ReynoldsNumber<T> From(Ratio<T> value) => Create(value.Value);
-/// <summary>Subtracts two ReynoldsNumber values, returning the absolute difference as a non-negative ReynoldsNumber.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ReynoldsNumber<T> operator -(ReynoldsNumber<T> left, ReynoldsNumber<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two ReynoldsNumber values, returning the absolute difference as a non-negative ReynoldsNumber.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ReynoldsNumber<T> operator -(ReynoldsNumber<T> left, ReynoldsNumber<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Rotation.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Rotation.g.cs
index 203eeffd..a0c851c1 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Rotation.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Rotation.g.cs
@@ -25,42 +25,50 @@ public partial record Rotation<T> : PhysicalQuantity<Rotation<T>, T>, IVector1<R
 	/// <param name="value">The value in Radian.</param>
 	/// <returns>A new Rotation instance.</returns>
 	public static Rotation<T> FromRadian(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Rotation from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new Rotation instance.</returns>
 	public static Rotation<T> FromDegree(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Rotation from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new Rotation instance.</returns>
 	public static Rotation<T> FromGradian(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Rotation from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new Rotation instance.</returns>
 	public static Rotation<T> FromRevolution(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Rotation from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new Rotation instance.</returns>
 	public static Rotation<T> FromMilliradian(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Milli)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AngularDisplacement unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAngularDisplacementUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to SignedAngle.</summary>
+
+	/// <summary>Implicit conversion to SignedAngle.</summary>
 	public static implicit operator SignedAngle<T>(Rotation<T> value) => SignedAngle<T>.Create(value.Value);
-/// <summary>Explicit conversion from SignedAngle.</summary>
+
+	/// <summary>Explicit conversion from SignedAngle.</summary>
 	public static explicit operator Rotation<T>(SignedAngle<T> value) => Create(value.Value);
-/// <summary>Creates a Rotation from a SignedAngle value.</summary>
+
+	/// <summary>Creates a Rotation from a SignedAngle value.</summary>
 	public static Rotation<T> From(SignedAngle<T> value) => Create(value.Value);
-};
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SamplingRate.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SamplingRate.g.cs
index 1eea3e76..fe146725 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SamplingRate.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SamplingRate.g.cs
@@ -26,34 +26,42 @@ public partial record SamplingRate<T> : PhysicalQuantity<SamplingRate<T>, T>, IV
 	/// <returns>A new SamplingRate instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SamplingRate<T> FromHertz(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SamplingRate from a value in Kilohertz.
 	/// </summary>
 	/// <param name="value">The value in Kilohertz.</param>
 	/// <returns>A new SamplingRate instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SamplingRate<T> FromKilohertz(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SamplingRate from a value in Megahertz.
 	/// </summary>
 	/// <param name="value">The value in Megahertz.</param>
 	/// <returns>A new SamplingRate instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SamplingRate<T> FromMegahertz(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Mega)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Frequency unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IFrequencyUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Frequency.</summary>
+
+	/// <summary>Implicit conversion to Frequency.</summary>
 	public static implicit operator Frequency<T>(SamplingRate<T> value) => Frequency<T>.Create(value.Value);
-/// <summary>Explicit conversion from Frequency.</summary>
+
+	/// <summary>Explicit conversion from Frequency.</summary>
 	public static explicit operator SamplingRate<T>(Frequency<T> value) => Create(value.Value);
-/// <summary>Creates a SamplingRate from a Frequency value.</summary>
+
+	/// <summary>Creates a SamplingRate from a Frequency value.</summary>
 	public static SamplingRate<T> From(Frequency<T> value) => Create(value.Value);
-/// <summary>Subtracts two SamplingRate values, returning the absolute difference as a non-negative SamplingRate.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SamplingRate<T> operator -(SamplingRate<T> left, SamplingRate<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two SamplingRate values, returning the absolute difference as a non-negative SamplingRate.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SamplingRate<T> operator -(SamplingRate<T> left, SamplingRate<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Sensitivity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Sensitivity.g.cs
index bc06625a..aa5cfc17 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Sensitivity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Sensitivity.g.cs
@@ -25,21 +25,26 @@ public partial record Sensitivity<T> : PhysicalQuantity<Sensitivity<T>, T>, IVec
 	/// <returns>A new <see cref="Sensitivity{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Sensitivity<T> FromVoltPerPascal(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Sensitivity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ISensitivityUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Sensitivity values, returning the absolute difference as a non-negative Sensitivity.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Sensitivity<T> operator -(Sensitivity<T> left, Sensitivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Sensitivity<T> operator -(Sensitivity<T> left, Sensitivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Sensitivity by Pressure to produce VoltageMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static VoltageMagnitude<T> operator *(Sensitivity<T> left, Pressure<T> right) => Multiply<VoltageMagnitude<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(Sensitivity<T> left, Pressure<T> right) => Multiply<VoltageMagnitude<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Sharpness.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Sharpness.g.cs
index 1b2378a9..49377b8a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Sharpness.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Sharpness.g.cs
@@ -25,17 +25,20 @@ public partial record Sharpness<T> : PhysicalQuantity<Sharpness<T>, T>, IVector0
 	/// <returns>A new <see cref="Sharpness{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Sharpness<T> FromAcum(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Sharpness unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ISharpnessUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Sharpness values, returning the absolute difference as a non-negative Sharpness.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Sharpness<T> operator -(Sharpness<T> left, Sharpness<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Sharpness<T> operator -(Sharpness<T> left, Sharpness<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ShearModulus.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ShearModulus.g.cs
index 767ea3cc..779b4201 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ShearModulus.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ShearModulus.g.cs
@@ -26,55 +26,66 @@ public partial record ShearModulus<T> : PhysicalQuantity<ShearModulus<T>, T>, IV
 	/// <returns>A new ShearModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ShearModulus<T> FromPascal(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ShearModulus from a value in Kilopascal.
 	/// </summary>
 	/// <param name="value">The value in Kilopascal.</param>
 	/// <returns>A new ShearModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ShearModulus<T> FromKilopascal(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ShearModulus from a value in Bar.
 	/// </summary>
 	/// <param name="value">The value in Bar.</param>
 	/// <returns>A new ShearModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ShearModulus<T> FromBar(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.BarToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ShearModulus from a value in Atmosphere.
 	/// </summary>
 	/// <param name="value">The value in Atmosphere.</param>
 	/// <returns>A new ShearModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ShearModulus<T> FromAtmosphere(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AtmosphereToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ShearModulus from a value in Psi.
 	/// </summary>
 	/// <param name="value">The value in Psi.</param>
 	/// <returns>A new ShearModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ShearModulus<T> FromPsi(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PsiToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ShearModulus from a value in Torr.
 	/// </summary>
 	/// <param name="value">The value in Torr.</param>
 	/// <returns>A new ShearModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ShearModulus<T> FromTorr(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.TorrToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Pressure unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IPressureUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Pressure.</summary>
+
+	/// <summary>Implicit conversion to Pressure.</summary>
 	public static implicit operator Pressure<T>(ShearModulus<T> value) => Pressure<T>.Create(value.Value);
-/// <summary>Explicit conversion from Pressure.</summary>
+
+	/// <summary>Explicit conversion from Pressure.</summary>
 	public static explicit operator ShearModulus<T>(Pressure<T> value) => Create(value.Value);
-/// <summary>Creates a ShearModulus from a Pressure value.</summary>
+
+	/// <summary>Creates a ShearModulus from a Pressure value.</summary>
 	public static ShearModulus<T> From(Pressure<T> value) => Create(value.Value);
-/// <summary>Subtracts two ShearModulus values, returning the absolute difference as a non-negative ShearModulus.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ShearModulus<T> operator -(ShearModulus<T> left, ShearModulus<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two ShearModulus values, returning the absolute difference as a non-negative ShearModulus.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ShearModulus<T> operator -(ShearModulus<T> left, ShearModulus<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SignedAngle.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SignedAngle.g.cs
index 7f8c004a..0f0c69ba 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SignedAngle.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SignedAngle.g.cs
@@ -24,45 +24,53 @@ public partial record SignedAngle<T> : PhysicalQuantity<SignedAngle<T>, T>, IVec
 	/// <param name="value">The value in Radian.</param>
 	/// <returns>A new <see cref="SignedAngle{T}"/> instance.</returns>
 	public static SignedAngle<T> FromRadian(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="SignedAngle{T}"/> from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new <see cref="SignedAngle{T}"/> instance.</returns>
 	public static SignedAngle<T> FromDegree(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="SignedAngle{T}"/> from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new <see cref="SignedAngle{T}"/> instance.</returns>
 	public static SignedAngle<T> FromGradian(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="SignedAngle{T}"/> from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new <see cref="SignedAngle{T}"/> instance.</returns>
 	public static SignedAngle<T> FromRevolution(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="SignedAngle{T}"/> from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new <see cref="SignedAngle{T}"/> instance.</returns>
 	public static SignedAngle<T> FromMilliradian(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Milli)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-AngularDisplacement unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAngularDisplacementUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="Angle{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public Angle<T> Magnitude() => Angle<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Divides SignedAngle by Duration to produce AngularVelocity1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularVelocity1D<T> operator /(SignedAngle<T> left, Duration<T> right) => Divide<AngularVelocity1D<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity1D<T> operator /(SignedAngle<T> left, Duration<T> right) => Divide<AngularVelocity1D<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SignedRatio.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SignedRatio.g.cs
index a5f7f9da..7f7467dd 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SignedRatio.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SignedRatio.g.cs
@@ -24,79 +24,94 @@ public partial record SignedRatio<T> : PhysicalQuantity<SignedRatio<T>, T>, IVec
 	/// <param name="value">The value in Dimensionless.</param>
 	/// <returns>A new <see cref="SignedRatio{T}"/> instance.</returns>
 	public static SignedRatio<T> FromDimensionless(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="SignedRatio{T}"/> from a value in Radian.
 	/// </summary>
 	/// <param name="value">The value in Radian.</param>
 	/// <returns>A new <see cref="SignedRatio{T}"/> instance.</returns>
 	public static SignedRatio<T> FromRadian(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="SignedRatio{T}"/> from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new <see cref="SignedRatio{T}"/> instance.</returns>
 	public static SignedRatio<T> FromDegree(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="SignedRatio{T}"/> from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new <see cref="SignedRatio{T}"/> instance.</returns>
 	public static SignedRatio<T> FromGradian(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="SignedRatio{T}"/> from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new <see cref="SignedRatio{T}"/> instance.</returns>
 	public static SignedRatio<T> FromRevolution(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="SignedRatio{T}"/> from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new <see cref="SignedRatio{T}"/> instance.</returns>
 	public static SignedRatio<T> FromMilliradian(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Milli)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="SignedRatio{T}"/> from a value in Percent.
 	/// </summary>
 	/// <param name="value">The value in Percent.</param>
 	/// <returns>A new <see cref="SignedRatio{T}"/> instance.</returns>
 	public static SignedRatio<T> FromPercent(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.PercentToRatio)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="SignedRatio{T}"/> from a value in PartPerMillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerMillion.</param>
 	/// <returns>A new <see cref="SignedRatio{T}"/> instance.</returns>
 	public static SignedRatio<T> FromPartPerMillion(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.PartPerMillionToRatio)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="SignedRatio{T}"/> from a value in PartPerBillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerBillion.</param>
 	/// <returns>A new <see cref="SignedRatio{T}"/> instance.</returns>
 	public static SignedRatio<T> FromPartPerBillion(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.PartPerBillionToRatio)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="SignedRatio{T}"/> from a value in PercentByWeight.
 	/// </summary>
 	/// <param name="value">The value in PercentByWeight.</param>
 	/// <returns>A new <see cref="SignedRatio{T}"/> instance.</returns>
 	public static SignedRatio<T> FromPercentByWeight(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.PercentByWeightToRatio)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Dimensionless unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IDimensionlessUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="Ratio{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public Ratio<T> Magnitude() => Ratio<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Multiplies SignedRatio by Ratio to produce SignedRatio.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SignedRatio<T> operator *(SignedRatio<T> left, Ratio<T> right) => Multiply<SignedRatio<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedRatio<T> operator *(SignedRatio<T> left, Ratio<T> right) => Multiply<SignedRatio<T>>(left, right);
+
+	/// <summary>
 	/// Divides SignedRatio by Ratio to produce SignedRatio.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SignedRatio<T> operator /(SignedRatio<T> left, Ratio<T> right) => Divide<SignedRatio<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedRatio<T> operator /(SignedRatio<T> left, Ratio<T> right) => Divide<SignedRatio<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Snap1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Snap1D.g.cs
index 6d938cb0..41d86fc9 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Snap1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Snap1D.g.cs
@@ -24,21 +24,25 @@ public partial record Snap1D<T> : PhysicalQuantity<Snap1D<T>, T>, IVector1<Snap1
 	/// <param name="value">The value in MeterPerSecondQuartic.</param>
 	/// <returns>A new <see cref="Snap1D{T}"/> instance.</returns>
 	public static Snap1D<T> FromMeterPerSecondQuartic(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Snap unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ISnapUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="SnapMagnitude{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public SnapMagnitude<T> Magnitude() => SnapMagnitude<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Multiplies Snap1D by Duration to produce Jerk1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Jerk1D<T> operator *(Snap1D<T> left, Duration<T> right) => Multiply<Jerk1D<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk1D<T> operator *(Snap1D<T> left, Duration<T> right) => Multiply<Jerk1D<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SnapMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SnapMagnitude.g.cs
index 5404a239..20ed3cb7 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SnapMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SnapMagnitude.g.cs
@@ -25,21 +25,26 @@ public partial record SnapMagnitude<T> : PhysicalQuantity<SnapMagnitude<T>, T>,
 	/// <returns>A new <see cref="SnapMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SnapMagnitude<T> FromMeterPerSecondQuartic(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Snap unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ISnapUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two SnapMagnitude values, returning the absolute difference as a non-negative SnapMagnitude.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SnapMagnitude<T> operator -(SnapMagnitude<T> left, SnapMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SnapMagnitude<T> operator -(SnapMagnitude<T> left, SnapMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies SnapMagnitude by Duration to produce JerkMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static JerkMagnitude<T> operator *(SnapMagnitude<T> left, Duration<T> right) => Multiply<JerkMagnitude<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static JerkMagnitude<T> operator *(SnapMagnitude<T> left, Duration<T> right) => Multiply<JerkMagnitude<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundAbsorption.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundAbsorption.g.cs
index 0053f0ee..ada4b32c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundAbsorption.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundAbsorption.g.cs
@@ -26,83 +26,98 @@ public partial record SoundAbsorption<T> : PhysicalQuantity<SoundAbsorption<T>,
 	/// <returns>A new SoundAbsorption instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundAbsorption<T> FromDimensionless(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundAbsorption from a value in Radian.
 	/// </summary>
 	/// <param name="value">The value in Radian.</param>
 	/// <returns>A new SoundAbsorption instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundAbsorption<T> FromRadian(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundAbsorption from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new SoundAbsorption instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundAbsorption<T> FromDegree(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundAbsorption from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new SoundAbsorption instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundAbsorption<T> FromGradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundAbsorption from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new SoundAbsorption instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundAbsorption<T> FromRevolution(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundAbsorption from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new SoundAbsorption instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundAbsorption<T> FromMilliradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundAbsorption from a value in Percent.
 	/// </summary>
 	/// <param name="value">The value in Percent.</param>
 	/// <returns>A new SoundAbsorption instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundAbsorption<T> FromPercent(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundAbsorption from a value in PartPerMillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerMillion.</param>
 	/// <returns>A new SoundAbsorption instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundAbsorption<T> FromPartPerMillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerMillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundAbsorption from a value in PartPerBillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerBillion.</param>
 	/// <returns>A new SoundAbsorption instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundAbsorption<T> FromPartPerBillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerBillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundAbsorption from a value in PercentByWeight.
 	/// </summary>
 	/// <param name="value">The value in PercentByWeight.</param>
 	/// <returns>A new SoundAbsorption instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundAbsorption<T> FromPercentByWeight(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentByWeightToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Dimensionless unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IDimensionlessUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Ratio.</summary>
+
+	/// <summary>Implicit conversion to Ratio.</summary>
 	public static implicit operator Ratio<T>(SoundAbsorption<T> value) => Ratio<T>.Create(value.Value);
-/// <summary>Explicit conversion from Ratio.</summary>
+
+	/// <summary>Explicit conversion from Ratio.</summary>
 	public static explicit operator SoundAbsorption<T>(Ratio<T> value) => Create(value.Value);
-/// <summary>Creates a SoundAbsorption from a Ratio value.</summary>
+
+	/// <summary>Creates a SoundAbsorption from a Ratio value.</summary>
 	public static SoundAbsorption<T> From(Ratio<T> value) => Create(value.Value);
-/// <summary>Subtracts two SoundAbsorption values, returning the absolute difference as a non-negative SoundAbsorption.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SoundAbsorption<T> operator -(SoundAbsorption<T> left, SoundAbsorption<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two SoundAbsorption values, returning the absolute difference as a non-negative SoundAbsorption.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SoundAbsorption<T> operator -(SoundAbsorption<T> left, SoundAbsorption<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundIntensity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundIntensity.g.cs
index 74c2d398..fbbba5d0 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundIntensity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundIntensity.g.cs
@@ -26,20 +26,26 @@ public partial record SoundIntensity<T> : PhysicalQuantity<SoundIntensity<T>, T>
 	/// <returns>A new SoundIntensity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundIntensity<T> FromWattPerSquareMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Irradiance unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IIrradianceUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Irradiance.</summary>
+
+	/// <summary>Implicit conversion to Irradiance.</summary>
 	public static implicit operator Irradiance<T>(SoundIntensity<T> value) => Irradiance<T>.Create(value.Value);
-/// <summary>Explicit conversion from Irradiance.</summary>
+
+	/// <summary>Explicit conversion from Irradiance.</summary>
 	public static explicit operator SoundIntensity<T>(Irradiance<T> value) => Create(value.Value);
-/// <summary>Creates a SoundIntensity from a Irradiance value.</summary>
+
+	/// <summary>Creates a SoundIntensity from a Irradiance value.</summary>
 	public static SoundIntensity<T> From(Irradiance<T> value) => Create(value.Value);
-/// <summary>Subtracts two SoundIntensity values, returning the absolute difference as a non-negative SoundIntensity.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SoundIntensity<T> operator -(SoundIntensity<T> left, SoundIntensity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two SoundIntensity values, returning the absolute difference as a non-negative SoundIntensity.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SoundIntensity<T> operator -(SoundIntensity<T> left, SoundIntensity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundPower.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundPower.g.cs
index 6db331ee..f73df78b 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundPower.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundPower.g.cs
@@ -26,41 +26,50 @@ public partial record SoundPower<T> : PhysicalQuantity<SoundPower<T>, T>, IVecto
 	/// <returns>A new SoundPower instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundPower<T> FromWatt(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundPower from a value in Kilowatt.
 	/// </summary>
 	/// <param name="value">The value in Kilowatt.</param>
 	/// <returns>A new SoundPower instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundPower<T> FromKilowatt(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundPower from a value in Megawatt.
 	/// </summary>
 	/// <param name="value">The value in Megawatt.</param>
 	/// <returns>A new SoundPower instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundPower<T> FromMegawatt(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Mega)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundPower from a value in Horsepower.
 	/// </summary>
 	/// <param name="value">The value in Horsepower.</param>
 	/// <returns>A new SoundPower instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundPower<T> FromHorsepower(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.HorsepowerToWatts)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Power unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IPowerUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Power.</summary>
+
+	/// <summary>Implicit conversion to Power.</summary>
 	public static implicit operator Power<T>(SoundPower<T> value) => Power<T>.Create(value.Value);
-/// <summary>Explicit conversion from Power.</summary>
+
+	/// <summary>Explicit conversion from Power.</summary>
 	public static explicit operator SoundPower<T>(Power<T> value) => Create(value.Value);
-/// <summary>Creates a SoundPower from a Power value.</summary>
+
+	/// <summary>Creates a SoundPower from a Power value.</summary>
 	public static SoundPower<T> From(Power<T> value) => Create(value.Value);
-/// <summary>Subtracts two SoundPower values, returning the absolute difference as a non-negative SoundPower.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SoundPower<T> operator -(SoundPower<T> left, SoundPower<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two SoundPower values, returning the absolute difference as a non-negative SoundPower.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SoundPower<T> operator -(SoundPower<T> left, SoundPower<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundPressure.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundPressure.g.cs
index 5543bc27..6221a366 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundPressure.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundPressure.g.cs
@@ -26,55 +26,66 @@ public partial record SoundPressure<T> : PhysicalQuantity<SoundPressure<T>, T>,
 	/// <returns>A new SoundPressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundPressure<T> FromPascal(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundPressure from a value in Kilopascal.
 	/// </summary>
 	/// <param name="value">The value in Kilopascal.</param>
 	/// <returns>A new SoundPressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundPressure<T> FromKilopascal(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundPressure from a value in Bar.
 	/// </summary>
 	/// <param name="value">The value in Bar.</param>
 	/// <returns>A new SoundPressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundPressure<T> FromBar(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.BarToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundPressure from a value in Atmosphere.
 	/// </summary>
 	/// <param name="value">The value in Atmosphere.</param>
 	/// <returns>A new SoundPressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundPressure<T> FromAtmosphere(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AtmosphereToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundPressure from a value in Psi.
 	/// </summary>
 	/// <param name="value">The value in Psi.</param>
 	/// <returns>A new SoundPressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundPressure<T> FromPsi(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PsiToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundPressure from a value in Torr.
 	/// </summary>
 	/// <param name="value">The value in Torr.</param>
 	/// <returns>A new SoundPressure instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundPressure<T> FromTorr(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.TorrToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Pressure unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IPressureUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Pressure.</summary>
+
+	/// <summary>Implicit conversion to Pressure.</summary>
 	public static implicit operator Pressure<T>(SoundPressure<T> value) => Pressure<T>.Create(value.Value);
-/// <summary>Explicit conversion from Pressure.</summary>
+
+	/// <summary>Explicit conversion from Pressure.</summary>
 	public static explicit operator SoundPressure<T>(Pressure<T> value) => Create(value.Value);
-/// <summary>Creates a SoundPressure from a Pressure value.</summary>
+
+	/// <summary>Creates a SoundPressure from a Pressure value.</summary>
 	public static SoundPressure<T> From(Pressure<T> value) => Create(value.Value);
-/// <summary>Subtracts two SoundPressure values, returning the absolute difference as a non-negative SoundPressure.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SoundPressure<T> operator -(SoundPressure<T> left, SoundPressure<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two SoundPressure values, returning the absolute difference as a non-negative SoundPressure.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SoundPressure<T> operator -(SoundPressure<T> left, SoundPressure<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundSpeed.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundSpeed.g.cs
index 5fdba00d..f5a5da7d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundSpeed.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundSpeed.g.cs
@@ -26,48 +26,58 @@ public partial record SoundSpeed<T> : PhysicalQuantity<SoundSpeed<T>, T>, IVecto
 	/// <returns>A new SoundSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundSpeed<T> FromMeterPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundSpeed from a value in KilometerPerHour.
 	/// </summary>
 	/// <param name="value">The value in KilometerPerHour.</param>
 	/// <returns>A new SoundSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundSpeed<T> FromKilometerPerHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilometerPerHourToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundSpeed from a value in MilePerHour.
 	/// </summary>
 	/// <param name="value">The value in MilePerHour.</param>
 	/// <returns>A new SoundSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundSpeed<T> FromMilePerHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MilePerHourToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundSpeed from a value in FootPerSecond.
 	/// </summary>
 	/// <param name="value">The value in FootPerSecond.</param>
 	/// <returns>A new SoundSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundSpeed<T> FromFootPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FootPerSecondToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundSpeed from a value in Knot.
 	/// </summary>
 	/// <param name="value">The value in Knot.</param>
 	/// <returns>A new SoundSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundSpeed<T> FromKnot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KnotToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Velocity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IVelocityUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Speed.</summary>
+
+	/// <summary>Implicit conversion to Speed.</summary>
 	public static implicit operator Speed<T>(SoundSpeed<T> value) => Speed<T>.Create(value.Value);
-/// <summary>Explicit conversion from Speed.</summary>
+
+	/// <summary>Explicit conversion from Speed.</summary>
 	public static explicit operator SoundSpeed<T>(Speed<T> value) => Create(value.Value);
-/// <summary>Creates a SoundSpeed from a Speed value.</summary>
+
+	/// <summary>Creates a SoundSpeed from a Speed value.</summary>
 	public static SoundSpeed<T> From(Speed<T> value) => Create(value.Value);
-/// <summary>Subtracts two SoundSpeed values, returning the absolute difference as a non-negative SoundSpeed.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SoundSpeed<T> operator -(SoundSpeed<T> left, SoundSpeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two SoundSpeed values, returning the absolute difference as a non-negative SoundSpeed.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SoundSpeed<T> operator -(SoundSpeed<T> left, SoundSpeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundTransmissionClass.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundTransmissionClass.g.cs
index cf8c60da..968a469b 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundTransmissionClass.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundTransmissionClass.g.cs
@@ -26,83 +26,98 @@ public partial record SoundTransmissionClass<T> : PhysicalQuantity<SoundTransmis
 	/// <returns>A new SoundTransmissionClass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundTransmissionClass<T> FromDimensionless(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundTransmissionClass from a value in Radian.
 	/// </summary>
 	/// <param name="value">The value in Radian.</param>
 	/// <returns>A new SoundTransmissionClass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundTransmissionClass<T> FromRadian(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundTransmissionClass from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new SoundTransmissionClass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundTransmissionClass<T> FromDegree(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundTransmissionClass from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new SoundTransmissionClass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundTransmissionClass<T> FromGradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundTransmissionClass from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new SoundTransmissionClass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundTransmissionClass<T> FromRevolution(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundTransmissionClass from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new SoundTransmissionClass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundTransmissionClass<T> FromMilliradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundTransmissionClass from a value in Percent.
 	/// </summary>
 	/// <param name="value">The value in Percent.</param>
 	/// <returns>A new SoundTransmissionClass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundTransmissionClass<T> FromPercent(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundTransmissionClass from a value in PartPerMillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerMillion.</param>
 	/// <returns>A new SoundTransmissionClass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundTransmissionClass<T> FromPartPerMillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerMillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundTransmissionClass from a value in PartPerBillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerBillion.</param>
 	/// <returns>A new SoundTransmissionClass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundTransmissionClass<T> FromPartPerBillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerBillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SoundTransmissionClass from a value in PercentByWeight.
 	/// </summary>
 	/// <param name="value">The value in PercentByWeight.</param>
 	/// <returns>A new SoundTransmissionClass instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SoundTransmissionClass<T> FromPercentByWeight(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentByWeightToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Dimensionless unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IDimensionlessUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Ratio.</summary>
+
+	/// <summary>Implicit conversion to Ratio.</summary>
 	public static implicit operator Ratio<T>(SoundTransmissionClass<T> value) => Ratio<T>.Create(value.Value);
-/// <summary>Explicit conversion from Ratio.</summary>
+
+	/// <summary>Explicit conversion from Ratio.</summary>
 	public static explicit operator SoundTransmissionClass<T>(Ratio<T> value) => Create(value.Value);
-/// <summary>Creates a SoundTransmissionClass from a Ratio value.</summary>
+
+	/// <summary>Creates a SoundTransmissionClass from a Ratio value.</summary>
 	public static SoundTransmissionClass<T> From(Ratio<T> value) => Create(value.Value);
-/// <summary>Subtracts two SoundTransmissionClass values, returning the absolute difference as a non-negative SoundTransmissionClass.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SoundTransmissionClass<T> operator -(SoundTransmissionClass<T> left, SoundTransmissionClass<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two SoundTransmissionClass values, returning the absolute difference as a non-negative SoundTransmissionClass.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SoundTransmissionClass<T> operator -(SoundTransmissionClass<T> left, SoundTransmissionClass<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificEntropy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificEntropy.g.cs
index 8acb0aad..0da7523c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificEntropy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificEntropy.g.cs
@@ -26,20 +26,26 @@ public partial record SpecificEntropy<T> : PhysicalQuantity<SpecificEntropy<T>,
 	/// <returns>A new SpecificEntropy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SpecificEntropy<T> FromJoulePerKilogramKelvin(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-SpecificHeat unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ISpecificHeatUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to SpecificHeat.</summary>
+
+	/// <summary>Implicit conversion to SpecificHeat.</summary>
 	public static implicit operator SpecificHeat<T>(SpecificEntropy<T> value) => SpecificHeat<T>.Create(value.Value);
-/// <summary>Explicit conversion from SpecificHeat.</summary>
+
+	/// <summary>Explicit conversion from SpecificHeat.</summary>
 	public static explicit operator SpecificEntropy<T>(SpecificHeat<T> value) => Create(value.Value);
-/// <summary>Creates a SpecificEntropy from a SpecificHeat value.</summary>
+
+	/// <summary>Creates a SpecificEntropy from a SpecificHeat value.</summary>
 	public static SpecificEntropy<T> From(SpecificHeat<T> value) => Create(value.Value);
-/// <summary>Subtracts two SpecificEntropy values, returning the absolute difference as a non-negative SpecificEntropy.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SpecificEntropy<T> operator -(SpecificEntropy<T> left, SpecificEntropy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two SpecificEntropy values, returning the absolute difference as a non-negative SpecificEntropy.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SpecificEntropy<T> operator -(SpecificEntropy<T> left, SpecificEntropy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificGravity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificGravity.g.cs
index 4c41f97b..a15c73fd 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificGravity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificGravity.g.cs
@@ -26,83 +26,98 @@ public partial record SpecificGravity<T> : PhysicalQuantity<SpecificGravity<T>,
 	/// <returns>A new SpecificGravity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SpecificGravity<T> FromDimensionless(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SpecificGravity from a value in Radian.
 	/// </summary>
 	/// <param name="value">The value in Radian.</param>
 	/// <returns>A new SpecificGravity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SpecificGravity<T> FromRadian(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SpecificGravity from a value in Degree.
 	/// </summary>
 	/// <param name="value">The value in Degree.</param>
 	/// <returns>A new SpecificGravity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SpecificGravity<T> FromDegree(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DegreeToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SpecificGravity from a value in Gradian.
 	/// </summary>
 	/// <param name="value">The value in Gradian.</param>
 	/// <returns>A new SpecificGravity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SpecificGravity<T> FromGradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GradianToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SpecificGravity from a value in Revolution.
 	/// </summary>
 	/// <param name="value">The value in Revolution.</param>
 	/// <returns>A new SpecificGravity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SpecificGravity<T> FromRevolution(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.RevolutionToRadians)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SpecificGravity from a value in Milliradian.
 	/// </summary>
 	/// <param name="value">The value in Milliradian.</param>
 	/// <returns>A new SpecificGravity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SpecificGravity<T> FromMilliradian(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SpecificGravity from a value in Percent.
 	/// </summary>
 	/// <param name="value">The value in Percent.</param>
 	/// <returns>A new SpecificGravity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SpecificGravity<T> FromPercent(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SpecificGravity from a value in PartPerMillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerMillion.</param>
 	/// <returns>A new SpecificGravity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SpecificGravity<T> FromPartPerMillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerMillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SpecificGravity from a value in PartPerBillion.
 	/// </summary>
 	/// <param name="value">The value in PartPerBillion.</param>
 	/// <returns>A new SpecificGravity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SpecificGravity<T> FromPartPerBillion(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PartPerBillionToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SpecificGravity from a value in PercentByWeight.
 	/// </summary>
 	/// <param name="value">The value in PercentByWeight.</param>
 	/// <returns>A new SpecificGravity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SpecificGravity<T> FromPercentByWeight(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PercentByWeightToRatio)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Dimensionless unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IDimensionlessUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Ratio.</summary>
+
+	/// <summary>Implicit conversion to Ratio.</summary>
 	public static implicit operator Ratio<T>(SpecificGravity<T> value) => Ratio<T>.Create(value.Value);
-/// <summary>Explicit conversion from Ratio.</summary>
+
+	/// <summary>Explicit conversion from Ratio.</summary>
 	public static explicit operator SpecificGravity<T>(Ratio<T> value) => Create(value.Value);
-/// <summary>Creates a SpecificGravity from a Ratio value.</summary>
+
+	/// <summary>Creates a SpecificGravity from a Ratio value.</summary>
 	public static SpecificGravity<T> From(Ratio<T> value) => Create(value.Value);
-/// <summary>Subtracts two SpecificGravity values, returning the absolute difference as a non-negative SpecificGravity.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SpecificGravity<T> operator -(SpecificGravity<T> left, SpecificGravity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two SpecificGravity values, returning the absolute difference as a non-negative SpecificGravity.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SpecificGravity<T> operator -(SpecificGravity<T> left, SpecificGravity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificHeat.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificHeat.g.cs
index b93e92a1..7622b0b9 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificHeat.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificHeat.g.cs
@@ -25,21 +25,26 @@ public partial record SpecificHeat<T> : PhysicalQuantity<SpecificHeat<T>, T>, IV
 	/// <returns>A new <see cref="SpecificHeat{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SpecificHeat<T> FromJoulePerKilogramKelvin(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-SpecificHeat unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ISpecificHeatUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two SpecificHeat values, returning the absolute difference as a non-negative SpecificHeat.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SpecificHeat<T> operator -(SpecificHeat<T> left, SpecificHeat<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SpecificHeat<T> operator -(SpecificHeat<T> left, SpecificHeat<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies SpecificHeat by Mass to produce Entropy.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Entropy<T> operator *(SpecificHeat<T> left, Mass<T> right) => Multiply<Entropy<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Entropy<T> operator *(SpecificHeat<T> left, Mass<T> right) => Multiply<Entropy<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Speed.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Speed.g.cs
index b510d940..deb83208 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Speed.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Speed.g.cs
@@ -25,73 +25,94 @@ public partial record Speed<T> : PhysicalQuantity<Speed<T>, T>, IVector0<Speed<T
 	/// <returns>A new <see cref="Speed{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Speed<T> FromMeterPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Speed{T}"/> from a value in KilometerPerHour.
 	/// </summary>
 	/// <param name="value">The value in KilometerPerHour.</param>
 	/// <returns>A new <see cref="Speed{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Speed<T> FromKilometerPerHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilometerPerHourToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Speed{T}"/> from a value in MilePerHour.
 	/// </summary>
 	/// <param name="value">The value in MilePerHour.</param>
 	/// <returns>A new <see cref="Speed{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Speed<T> FromMilePerHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MilePerHourToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Speed{T}"/> from a value in FootPerSecond.
 	/// </summary>
 	/// <param name="value">The value in FootPerSecond.</param>
 	/// <returns>A new <see cref="Speed{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Speed<T> FromFootPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FootPerSecondToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Speed{T}"/> from a value in Knot.
 	/// </summary>
 	/// <param name="value">The value in Knot.</param>
 	/// <returns>A new <see cref="Speed{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Speed<T> FromKnot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KnotToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Velocity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IVelocityUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Speed values, returning the absolute difference as a non-negative Speed.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Speed<T> operator -(Speed<T> left, Speed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator -(Speed<T> left, Speed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Speed by Mass to produce MomentumMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MomentumMagnitude<T> operator *(Speed<T> left, Mass<T> right) => Multiply<MomentumMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(Speed<T> left, Mass<T> right) => Multiply<MomentumMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Speed by Duration to produce Length.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Length<T> operator *(Speed<T> left, Duration<T> right) => Multiply<Length<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator *(Speed<T> left, Duration<T> right) => Multiply<Length<T>>(left, right);
+
+	/// <summary>
 	/// Divides Speed by Duration to produce AccelerationMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AccelerationMagnitude<T> operator /(Speed<T> left, Duration<T> right) => Divide<AccelerationMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator /(Speed<T> left, Duration<T> right) => Divide<AccelerationMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides Speed by AccelerationMagnitude to produce Duration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Duration<T> operator /(Speed<T> left, AccelerationMagnitude<T> right) => Divide<Duration<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Speed<T> left, AccelerationMagnitude<T> right) => Divide<Duration<T>>(left, right);
+
+	/// <summary>
 	/// Divides Speed by Length to produce Frequency.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Frequency<T> operator /(Speed<T> left, Length<T> right) => Divide<Frequency<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator /(Speed<T> left, Length<T> right) => Divide<Frequency<T>>(left, right);
+
+	/// <summary>
 	/// Divides Speed by Frequency to produce Length.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Length<T> operator /(Speed<T> left, Frequency<T> right) => Divide<Length<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(Speed<T> left, Frequency<T> right) => Divide<Length<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Speed by ForceMagnitude to produce Power.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Power<T> operator *(Speed<T> left, ForceMagnitude<T> right) => Multiply<Power<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(Speed<T> left, ForceMagnitude<T> right) => Multiply<Power<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Stress.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Stress.g.cs
index b3f6c67e..04590150 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Stress.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Stress.g.cs
@@ -26,55 +26,66 @@ public partial record Stress<T> : PhysicalQuantity<Stress<T>, T>, IVector0<Stres
 	/// <returns>A new Stress instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Stress<T> FromPascal(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Stress from a value in Kilopascal.
 	/// </summary>
 	/// <param name="value">The value in Kilopascal.</param>
 	/// <returns>A new Stress instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Stress<T> FromKilopascal(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Stress from a value in Bar.
 	/// </summary>
 	/// <param name="value">The value in Bar.</param>
 	/// <returns>A new Stress instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Stress<T> FromBar(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.BarToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Stress from a value in Atmosphere.
 	/// </summary>
 	/// <param name="value">The value in Atmosphere.</param>
 	/// <returns>A new Stress instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Stress<T> FromAtmosphere(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AtmosphereToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Stress from a value in Psi.
 	/// </summary>
 	/// <param name="value">The value in Psi.</param>
 	/// <returns>A new Stress instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Stress<T> FromPsi(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PsiToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Stress from a value in Torr.
 	/// </summary>
 	/// <param name="value">The value in Torr.</param>
 	/// <returns>A new Stress instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Stress<T> FromTorr(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.TorrToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Pressure unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IPressureUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Pressure.</summary>
+
+	/// <summary>Implicit conversion to Pressure.</summary>
 	public static implicit operator Pressure<T>(Stress<T> value) => Pressure<T>.Create(value.Value);
-/// <summary>Explicit conversion from Pressure.</summary>
+
+	/// <summary>Explicit conversion from Pressure.</summary>
 	public static explicit operator Stress<T>(Pressure<T> value) => Create(value.Value);
-/// <summary>Creates a Stress from a Pressure value.</summary>
+
+	/// <summary>Creates a Stress from a Pressure value.</summary>
 	public static Stress<T> From(Pressure<T> value) => Create(value.Value);
-/// <summary>Subtracts two Stress values, returning the absolute difference as a non-negative Stress.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Stress<T> operator -(Stress<T> left, Stress<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Stress values, returning the absolute difference as a non-negative Stress.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Stress<T> operator -(Stress<T> left, Stress<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SurfaceArea.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SurfaceArea.g.cs
index 6f9f28fd..aec49e8d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SurfaceArea.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SurfaceArea.g.cs
@@ -26,69 +26,82 @@ public partial record SurfaceArea<T> : PhysicalQuantity<SurfaceArea<T>, T>, IVec
 	/// <returns>A new SurfaceArea instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SurfaceArea<T> FromSquareMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SurfaceArea from a value in SquareKilometer.
 	/// </summary>
 	/// <param name="value">The value in SquareKilometer.</param>
 	/// <returns>A new SurfaceArea instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SurfaceArea<T> FromSquareKilometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.SquareKilometerToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SurfaceArea from a value in SquareCentimeter.
 	/// </summary>
 	/// <param name="value">The value in SquareCentimeter.</param>
 	/// <returns>A new SurfaceArea instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SurfaceArea<T> FromSquareCentimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.SquareCentimeterToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SurfaceArea from a value in SquareFoot.
 	/// </summary>
 	/// <param name="value">The value in SquareFoot.</param>
 	/// <returns>A new SurfaceArea instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SurfaceArea<T> FromSquareFoot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.SquareFootToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SurfaceArea from a value in SquareInch.
 	/// </summary>
 	/// <param name="value">The value in SquareInch.</param>
 	/// <returns>A new SurfaceArea instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SurfaceArea<T> FromSquareInch(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.SquareInchToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SurfaceArea from a value in SquareMile.
 	/// </summary>
 	/// <param name="value">The value in SquareMile.</param>
 	/// <returns>A new SurfaceArea instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SurfaceArea<T> FromSquareMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.SquareMileToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SurfaceArea from a value in Hectare.
 	/// </summary>
 	/// <param name="value">The value in Hectare.</param>
 	/// <returns>A new SurfaceArea instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SurfaceArea<T> FromHectare(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.HectareToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new SurfaceArea from a value in Acre.
 	/// </summary>
 	/// <param name="value">The value in Acre.</param>
 	/// <returns>A new SurfaceArea instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SurfaceArea<T> FromAcre(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AcreToSquareMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Area unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IAreaUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Area.</summary>
+
+	/// <summary>Implicit conversion to Area.</summary>
 	public static implicit operator Area<T>(SurfaceArea<T> value) => Area<T>.Create(value.Value);
-/// <summary>Explicit conversion from Area.</summary>
+
+	/// <summary>Explicit conversion from Area.</summary>
 	public static explicit operator SurfaceArea<T>(Area<T> value) => Create(value.Value);
-/// <summary>Creates a SurfaceArea from a Area value.</summary>
+
+	/// <summary>Creates a SurfaceArea from a Area value.</summary>
 	public static SurfaceArea<T> From(Area<T> value) => Create(value.Value);
-/// <summary>Subtracts two SurfaceArea values, returning the absolute difference as a non-negative SurfaceArea.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SurfaceArea<T> operator -(SurfaceArea<T> left, SurfaceArea<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two SurfaceArea values, returning the absolute difference as a non-negative SurfaceArea.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SurfaceArea<T> operator -(SurfaceArea<T> left, SurfaceArea<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SurfaceTension.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SurfaceTension.g.cs
index 15f5dbef..462db0e9 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SurfaceTension.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SurfaceTension.g.cs
@@ -25,28 +25,34 @@ public partial record SurfaceTension<T> : PhysicalQuantity<SurfaceTension<T>, T>
 	/// <returns>A new <see cref="SurfaceTension{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SurfaceTension<T> FromNewtonPerMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="SurfaceTension{T}"/> from a value in DynePerCentimeter.
 	/// </summary>
 	/// <param name="value">The value in DynePerCentimeter.</param>
 	/// <returns>A new <see cref="SurfaceTension{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static SurfaceTension<T> FromDynePerCentimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DynePerCentimeterToNewtonPerMeter)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-SurfaceTension unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ISurfaceTensionUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two SurfaceTension values, returning the absolute difference as a non-negative SurfaceTension.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static SurfaceTension<T> operator -(SurfaceTension<T> left, SurfaceTension<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SurfaceTension<T> operator -(SurfaceTension<T> left, SurfaceTension<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies SurfaceTension by Length to produce ForceMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ForceMagnitude<T> operator *(SurfaceTension<T> left, Length<T> right) => Multiply<ForceMagnitude<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(SurfaceTension<T> left, Length<T> right) => Multiply<ForceMagnitude<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Temperature.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Temperature.g.cs
index 6171d3ea..f2e545e2 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Temperature.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Temperature.g.cs
@@ -25,46 +25,56 @@ public partial record Temperature<T> : PhysicalQuantity<Temperature<T>, T>, IVec
 	/// <returns>A new <see cref="Temperature{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Temperature<T> FromKelvin(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Temperature{T}"/> from a value in Celsius.
 	/// </summary>
 	/// <param name="value">The value in Celsius.</param>
 	/// <returns>A new <see cref="Temperature{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Temperature<T> FromCelsius(T value) => Create(Vector0Guards.EnsureNonNegative((value + T.CreateChecked(Units.ConversionConstants.CelsiusToKelvinOffset)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Temperature{T}"/> from a value in Fahrenheit.
 	/// </summary>
 	/// <param name="value">The value in Fahrenheit.</param>
 	/// <returns>A new <see cref="Temperature{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Temperature<T> FromFahrenheit(T value) => Create(Vector0Guards.EnsureNonNegative(((value * T.CreateChecked(Units.ConversionConstants.FahrenheitScale)) + T.CreateChecked(Units.ConversionConstants.FahrenheitToKelvinOffset)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Temperature{T}"/> from a value in Rankine.
 	/// </summary>
 	/// <param name="value">The value in Rankine.</param>
 	/// <returns>A new <see cref="Temperature{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Temperature<T> FromRankine(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FahrenheitScale)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Temperature unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ITemperatureUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Temperature values, returning the absolute difference as a non-negative Temperature.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Temperature<T> operator -(Temperature<T> left, Temperature<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Temperature<T> operator -(Temperature<T> left, Temperature<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies Temperature by Entropy to produce Energy.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Energy<T> operator *(Temperature<T> left, Entropy<T> right) => Multiply<Energy<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Temperature<T> left, Entropy<T> right) => Multiply<Energy<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Temperature by ThermalExpansionCoefficient to produce Ratio.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Ratio<T> operator *(Temperature<T> left, ThermalExpansionCoefficient<T> right) => Multiply<Ratio<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(Temperature<T> left, ThermalExpansionCoefficient<T> right) => Multiply<Ratio<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TemperatureDelta.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TemperatureDelta.g.cs
index e0eaf633..60f49517 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TemperatureDelta.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TemperatureDelta.g.cs
@@ -24,35 +24,40 @@ public partial record TemperatureDelta<T> : PhysicalQuantity<TemperatureDelta<T>
 	/// <param name="value">The value in Kelvin.</param>
 	/// <returns>A new <see cref="TemperatureDelta{T}"/> instance.</returns>
 	public static TemperatureDelta<T> FromKelvin(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="TemperatureDelta{T}"/> from a value in Celsius.
 	/// </summary>
 	/// <param name="value">The value in Celsius.</param>
 	/// <returns>A new <see cref="TemperatureDelta{T}"/> instance.</returns>
 	public static TemperatureDelta<T> FromCelsius(T value) => Create((value + T.CreateChecked(Units.ConversionConstants.CelsiusToKelvinOffset)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="TemperatureDelta{T}"/> from a value in Fahrenheit.
 	/// </summary>
 	/// <param name="value">The value in Fahrenheit.</param>
 	/// <returns>A new <see cref="TemperatureDelta{T}"/> instance.</returns>
 	public static TemperatureDelta<T> FromFahrenheit(T value) => Create(((value * T.CreateChecked(Units.ConversionConstants.FahrenheitScale)) + T.CreateChecked(Units.ConversionConstants.FahrenheitToKelvinOffset)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="TemperatureDelta{T}"/> from a value in Rankine.
 	/// </summary>
 	/// <param name="value">The value in Rankine.</param>
 	/// <returns>A new <see cref="TemperatureDelta{T}"/> instance.</returns>
 	public static TemperatureDelta<T> FromRankine(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.FahrenheitScale)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Temperature unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ITemperatureUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="Temperature{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public Temperature<T> Magnitude() => Temperature<T>.Create(T.Abs(Value));
-};
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TemperatureDrop.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TemperatureDrop.g.cs
index d5c3ba49..647e383c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TemperatureDrop.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TemperatureDrop.g.cs
@@ -25,36 +25,43 @@ public partial record TemperatureDrop<T> : PhysicalQuantity<TemperatureDrop<T>,
 	/// <param name="value">The value in Kelvin.</param>
 	/// <returns>A new TemperatureDrop instance.</returns>
 	public static TemperatureDrop<T> FromKelvin(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new TemperatureDrop from a value in Celsius.
 	/// </summary>
 	/// <param name="value">The value in Celsius.</param>
 	/// <returns>A new TemperatureDrop instance.</returns>
 	public static TemperatureDrop<T> FromCelsius(T value) => Create((value + T.CreateChecked(Units.ConversionConstants.CelsiusToKelvinOffset)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new TemperatureDrop from a value in Fahrenheit.
 	/// </summary>
 	/// <param name="value">The value in Fahrenheit.</param>
 	/// <returns>A new TemperatureDrop instance.</returns>
 	public static TemperatureDrop<T> FromFahrenheit(T value) => Create(((value * T.CreateChecked(Units.ConversionConstants.FahrenheitScale)) + T.CreateChecked(Units.ConversionConstants.FahrenheitToKelvinOffset)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new TemperatureDrop from a value in Rankine.
 	/// </summary>
 	/// <param name="value">The value in Rankine.</param>
 	/// <returns>A new TemperatureDrop instance.</returns>
 	public static TemperatureDrop<T> FromRankine(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.FahrenheitScale)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Temperature unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ITemperatureUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to TemperatureDelta.</summary>
+
+	/// <summary>Implicit conversion to TemperatureDelta.</summary>
 	public static implicit operator TemperatureDelta<T>(TemperatureDrop<T> value) => TemperatureDelta<T>.Create(value.Value);
-/// <summary>Explicit conversion from TemperatureDelta.</summary>
+
+	/// <summary>Explicit conversion from TemperatureDelta.</summary>
 	public static explicit operator TemperatureDrop<T>(TemperatureDelta<T> value) => Create(value.Value);
-/// <summary>Creates a TemperatureDrop from a TemperatureDelta value.</summary>
+
+	/// <summary>Creates a TemperatureDrop from a TemperatureDelta value.</summary>
 	public static TemperatureDrop<T> From(TemperatureDelta<T> value) => Create(value.Value);
-};
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TemperatureRise.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TemperatureRise.g.cs
index 5bf09b02..faff8c4a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TemperatureRise.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TemperatureRise.g.cs
@@ -25,36 +25,43 @@ public partial record TemperatureRise<T> : PhysicalQuantity<TemperatureRise<T>,
 	/// <param name="value">The value in Kelvin.</param>
 	/// <returns>A new TemperatureRise instance.</returns>
 	public static TemperatureRise<T> FromKelvin(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new TemperatureRise from a value in Celsius.
 	/// </summary>
 	/// <param name="value">The value in Celsius.</param>
 	/// <returns>A new TemperatureRise instance.</returns>
 	public static TemperatureRise<T> FromCelsius(T value) => Create((value + T.CreateChecked(Units.ConversionConstants.CelsiusToKelvinOffset)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new TemperatureRise from a value in Fahrenheit.
 	/// </summary>
 	/// <param name="value">The value in Fahrenheit.</param>
 	/// <returns>A new TemperatureRise instance.</returns>
 	public static TemperatureRise<T> FromFahrenheit(T value) => Create(((value * T.CreateChecked(Units.ConversionConstants.FahrenheitScale)) + T.CreateChecked(Units.ConversionConstants.FahrenheitToKelvinOffset)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new TemperatureRise from a value in Rankine.
 	/// </summary>
 	/// <param name="value">The value in Rankine.</param>
 	/// <returns>A new TemperatureRise instance.</returns>
 	public static TemperatureRise<T> FromRankine(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.FahrenheitScale)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Temperature unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ITemperatureUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to TemperatureDelta.</summary>
+
+	/// <summary>Implicit conversion to TemperatureDelta.</summary>
 	public static implicit operator TemperatureDelta<T>(TemperatureRise<T> value) => TemperatureDelta<T>.Create(value.Value);
-/// <summary>Explicit conversion from TemperatureDelta.</summary>
+
+	/// <summary>Explicit conversion from TemperatureDelta.</summary>
 	public static explicit operator TemperatureRise<T>(TemperatureDelta<T> value) => Create(value.Value);
-/// <summary>Creates a TemperatureRise from a TemperatureDelta value.</summary>
+
+	/// <summary>Creates a TemperatureRise from a TemperatureDelta value.</summary>
 	public static TemperatureRise<T> From(TemperatureDelta<T> value) => Create(value.Value);
-};
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Tension.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Tension.g.cs
index 4784d9ff..f9182325 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Tension.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Tension.g.cs
@@ -26,41 +26,50 @@ public partial record Tension<T> : PhysicalQuantity<Tension<T>, T>, IVector0<Ten
 	/// <returns>A new Tension instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Tension<T> FromNewton(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Tension from a value in Kilonewton.
 	/// </summary>
 	/// <param name="value">The value in Kilonewton.</param>
 	/// <returns>A new Tension instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Tension<T> FromKilonewton(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Tension from a value in Dyne.
 	/// </summary>
 	/// <param name="value">The value in Dyne.</param>
 	/// <returns>A new Tension instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Tension<T> FromDyne(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DyneToNewtons)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Tension from a value in PoundForce.
 	/// </summary>
 	/// <param name="value">The value in PoundForce.</param>
 	/// <returns>A new Tension instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Tension<T> FromPoundForce(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PoundForceToNewtons)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Force unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IForceUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to ForceMagnitude.</summary>
+
+	/// <summary>Implicit conversion to ForceMagnitude.</summary>
 	public static implicit operator ForceMagnitude<T>(Tension<T> value) => ForceMagnitude<T>.Create(value.Value);
-/// <summary>Explicit conversion from ForceMagnitude.</summary>
+
+	/// <summary>Explicit conversion from ForceMagnitude.</summary>
 	public static explicit operator Tension<T>(ForceMagnitude<T> value) => Create(value.Value);
-/// <summary>Creates a Tension from a ForceMagnitude value.</summary>
+
+	/// <summary>Creates a Tension from a ForceMagnitude value.</summary>
 	public static Tension<T> From(ForceMagnitude<T> value) => Create(value.Value);
-/// <summary>Subtracts two Tension values, returning the absolute difference as a non-negative Tension.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Tension<T> operator -(Tension<T> left, Tension<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Tension values, returning the absolute difference as a non-negative Tension.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Tension<T> operator -(Tension<T> left, Tension<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalConductivity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalConductivity.g.cs
index 4e881439..711f1942 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalConductivity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalConductivity.g.cs
@@ -25,17 +25,20 @@ public partial record ThermalConductivity<T> : PhysicalQuantity<ThermalConductiv
 	/// <returns>A new <see cref="ThermalConductivity{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ThermalConductivity<T> FromWattPerMeterKelvin(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ThermalConductivity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IThermalConductivityUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two ThermalConductivity values, returning the absolute difference as a non-negative ThermalConductivity.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ThermalConductivity<T> operator -(ThermalConductivity<T> left, ThermalConductivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ThermalConductivity<T> operator -(ThermalConductivity<T> left, ThermalConductivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalDiffusivity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalDiffusivity.g.cs
index af33181c..11219363 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalDiffusivity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalDiffusivity.g.cs
@@ -26,27 +26,34 @@ public partial record ThermalDiffusivity<T> : PhysicalQuantity<ThermalDiffusivit
 	/// <returns>A new ThermalDiffusivity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ThermalDiffusivity<T> FromSquareMeterPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ThermalDiffusivity from a value in Stokes.
 	/// </summary>
 	/// <param name="value">The value in Stokes.</param>
 	/// <returns>A new ThermalDiffusivity instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ThermalDiffusivity<T> FromStokes(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.StokesToSquareMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-KinematicViscosity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IKinematicViscosityUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to KinematicViscosity.</summary>
+
+	/// <summary>Implicit conversion to KinematicViscosity.</summary>
 	public static implicit operator KinematicViscosity<T>(ThermalDiffusivity<T> value) => KinematicViscosity<T>.Create(value.Value);
-/// <summary>Explicit conversion from KinematicViscosity.</summary>
+
+	/// <summary>Explicit conversion from KinematicViscosity.</summary>
 	public static explicit operator ThermalDiffusivity<T>(KinematicViscosity<T> value) => Create(value.Value);
-/// <summary>Creates a ThermalDiffusivity from a KinematicViscosity value.</summary>
+
+	/// <summary>Creates a ThermalDiffusivity from a KinematicViscosity value.</summary>
 	public static ThermalDiffusivity<T> From(KinematicViscosity<T> value) => Create(value.Value);
-/// <summary>Subtracts two ThermalDiffusivity values, returning the absolute difference as a non-negative ThermalDiffusivity.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ThermalDiffusivity<T> operator -(ThermalDiffusivity<T> left, ThermalDiffusivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two ThermalDiffusivity values, returning the absolute difference as a non-negative ThermalDiffusivity.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ThermalDiffusivity<T> operator -(ThermalDiffusivity<T> left, ThermalDiffusivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalEnergy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalEnergy.g.cs
index f54b3ffa..a4a372e1 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalEnergy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalEnergy.g.cs
@@ -26,76 +26,90 @@ public partial record ThermalEnergy<T> : PhysicalQuantity<ThermalEnergy<T>, T>,
 	/// <returns>A new ThermalEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ThermalEnergy<T> FromJoule(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ThermalEnergy from a value in Kilojoule.
 	/// </summary>
 	/// <param name="value">The value in Kilojoule.</param>
 	/// <returns>A new ThermalEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ThermalEnergy<T> FromKilojoule(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ThermalEnergy from a value in ElectronVolt.
 	/// </summary>
 	/// <param name="value">The value in ElectronVolt.</param>
 	/// <returns>A new ThermalEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ThermalEnergy<T> FromElectronVolt(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.ElectronVoltToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ThermalEnergy from a value in Calorie.
 	/// </summary>
 	/// <param name="value">The value in Calorie.</param>
 	/// <returns>A new ThermalEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ThermalEnergy<T> FromCalorie(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.CalorieToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ThermalEnergy from a value in Kilocalorie.
 	/// </summary>
 	/// <param name="value">The value in Kilocalorie.</param>
 	/// <returns>A new ThermalEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ThermalEnergy<T> FromKilocalorie(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilocalorieToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ThermalEnergy from a value in KilowattHour.
 	/// </summary>
 	/// <param name="value">The value in KilowattHour.</param>
 	/// <returns>A new ThermalEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ThermalEnergy<T> FromKilowattHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilowattHourToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ThermalEnergy from a value in WattHour.
 	/// </summary>
 	/// <param name="value">The value in WattHour.</param>
 	/// <returns>A new ThermalEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ThermalEnergy<T> FromWattHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.WattHourToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ThermalEnergy from a value in Erg.
 	/// </summary>
 	/// <param name="value">The value in Erg.</param>
 	/// <returns>A new ThermalEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ThermalEnergy<T> FromErg(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.ErgToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new ThermalEnergy from a value in Btu.
 	/// </summary>
 	/// <param name="value">The value in Btu.</param>
 	/// <returns>A new ThermalEnergy instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ThermalEnergy<T> FromBtu(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.BtuToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Energy unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IEnergyUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Energy.</summary>
+
+	/// <summary>Implicit conversion to Energy.</summary>
 	public static implicit operator Energy<T>(ThermalEnergy<T> value) => Energy<T>.Create(value.Value);
-/// <summary>Explicit conversion from Energy.</summary>
+
+	/// <summary>Explicit conversion from Energy.</summary>
 	public static explicit operator ThermalEnergy<T>(Energy<T> value) => Create(value.Value);
-/// <summary>Creates a ThermalEnergy from a Energy value.</summary>
+
+	/// <summary>Creates a ThermalEnergy from a Energy value.</summary>
 	public static ThermalEnergy<T> From(Energy<T> value) => Create(value.Value);
-/// <summary>Subtracts two ThermalEnergy values, returning the absolute difference as a non-negative ThermalEnergy.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ThermalEnergy<T> operator -(ThermalEnergy<T> left, ThermalEnergy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two ThermalEnergy values, returning the absolute difference as a non-negative ThermalEnergy.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ThermalEnergy<T> operator -(ThermalEnergy<T> left, ThermalEnergy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalExpansionCoefficient.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalExpansionCoefficient.g.cs
index 355b3fe9..8cd493c5 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalExpansionCoefficient.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalExpansionCoefficient.g.cs
@@ -25,21 +25,26 @@ public partial record ThermalExpansionCoefficient<T> : PhysicalQuantity<ThermalE
 	/// <returns>A new <see cref="ThermalExpansionCoefficient{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ThermalExpansionCoefficient<T> FromPerKelvin(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ThermalExpansion unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IThermalExpansionUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two ThermalExpansionCoefficient values, returning the absolute difference as a non-negative ThermalExpansionCoefficient.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ThermalExpansionCoefficient<T> operator -(ThermalExpansionCoefficient<T> left, ThermalExpansionCoefficient<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ThermalExpansionCoefficient<T> operator -(ThermalExpansionCoefficient<T> left, ThermalExpansionCoefficient<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies ThermalExpansionCoefficient by Temperature to produce Ratio.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Ratio<T> operator *(ThermalExpansionCoefficient<T> left, Temperature<T> right) => Multiply<Ratio<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(ThermalExpansionCoefficient<T> left, Temperature<T> right) => Multiply<Ratio<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalResistance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalResistance.g.cs
index 1d644453..be6cd27f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalResistance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalResistance.g.cs
@@ -25,17 +25,20 @@ public partial record ThermalResistance<T> : PhysicalQuantity<ThermalResistance<
 	/// <returns>A new <see cref="ThermalResistance{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static ThermalResistance<T> FromKelvinPerWatt(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ThermalResistance unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IThermalResistanceUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two ThermalResistance values, returning the absolute difference as a non-negative ThermalResistance.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ThermalResistance<T> operator -(ThermalResistance<T> left, ThermalResistance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ThermalResistance<T> operator -(ThermalResistance<T> left, ThermalResistance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Thickness.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Thickness.g.cs
index 33db5a94..14f35819 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Thickness.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Thickness.g.cs
@@ -26,97 +26,114 @@ public partial record Thickness<T> : PhysicalQuantity<Thickness<T>, T>, IVector0
 	/// <returns>A new Thickness instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Thickness<T> FromMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Thickness from a value in Kilometer.
 	/// </summary>
 	/// <param name="value">The value in Kilometer.</param>
 	/// <returns>A new Thickness instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Thickness<T> FromKilometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Thickness from a value in Centimeter.
 	/// </summary>
 	/// <param name="value">The value in Centimeter.</param>
 	/// <returns>A new Thickness instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Thickness<T> FromCentimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Centi)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Thickness from a value in Millimeter.
 	/// </summary>
 	/// <param name="value">The value in Millimeter.</param>
 	/// <returns>A new Thickness instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Thickness<T> FromMillimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Thickness from a value in Micrometer.
 	/// </summary>
 	/// <param name="value">The value in Micrometer.</param>
 	/// <returns>A new Thickness instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Thickness<T> FromMicrometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Thickness from a value in Nanometer.
 	/// </summary>
 	/// <param name="value">The value in Nanometer.</param>
 	/// <returns>A new Thickness instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Thickness<T> FromNanometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Thickness from a value in Angstrom.
 	/// </summary>
 	/// <param name="value">The value in Angstrom.</param>
 	/// <returns>A new Thickness instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Thickness<T> FromAngstrom(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AngstromToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Thickness from a value in Foot.
 	/// </summary>
 	/// <param name="value">The value in Foot.</param>
 	/// <returns>A new Thickness instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Thickness<T> FromFoot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FeetToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Thickness from a value in Inch.
 	/// </summary>
 	/// <param name="value">The value in Inch.</param>
 	/// <returns>A new Thickness instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Thickness<T> FromInch(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.InchesToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Thickness from a value in Yard.
 	/// </summary>
 	/// <param name="value">The value in Yard.</param>
 	/// <returns>A new Thickness instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Thickness<T> FromYard(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YardToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Thickness from a value in Mile.
 	/// </summary>
 	/// <param name="value">The value in Mile.</param>
 	/// <returns>A new Thickness instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Thickness<T> FromMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Thickness from a value in NauticalMile.
 	/// </summary>
 	/// <param name="value">The value in NauticalMile.</param>
 	/// <returns>A new Thickness instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Thickness<T> FromNauticalMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.NauticalMileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Length unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Length.</summary>
+
+	/// <summary>Implicit conversion to Length.</summary>
 	public static implicit operator Length<T>(Thickness<T> value) => Length<T>.Create(value.Value);
-/// <summary>Explicit conversion from Length.</summary>
+
+	/// <summary>Explicit conversion from Length.</summary>
 	public static explicit operator Thickness<T>(Length<T> value) => Create(value.Value);
-/// <summary>Creates a Thickness from a Length value.</summary>
+
+	/// <summary>Creates a Thickness from a Length value.</summary>
 	public static Thickness<T> From(Length<T> value) => Create(value.Value);
-/// <summary>Subtracts two Thickness values, returning the absolute difference as a non-negative Thickness.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Thickness<T> operator -(Thickness<T> left, Thickness<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Thickness values, returning the absolute difference as a non-negative Thickness.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Thickness<T> operator -(Thickness<T> left, Thickness<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Thrust.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Thrust.g.cs
index c62ce8e1..608a1c51 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Thrust.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Thrust.g.cs
@@ -26,41 +26,50 @@ public partial record Thrust<T> : PhysicalQuantity<Thrust<T>, T>, IVector0<Thrus
 	/// <returns>A new Thrust instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Thrust<T> FromNewton(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Thrust from a value in Kilonewton.
 	/// </summary>
 	/// <param name="value">The value in Kilonewton.</param>
 	/// <returns>A new Thrust instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Thrust<T> FromKilonewton(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Thrust from a value in Dyne.
 	/// </summary>
 	/// <param name="value">The value in Dyne.</param>
 	/// <returns>A new Thrust instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Thrust<T> FromDyne(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DyneToNewtons)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Thrust from a value in PoundForce.
 	/// </summary>
 	/// <param name="value">The value in PoundForce.</param>
 	/// <returns>A new Thrust instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Thrust<T> FromPoundForce(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PoundForceToNewtons)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Force unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IForceUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to ForceMagnitude.</summary>
+
+	/// <summary>Implicit conversion to ForceMagnitude.</summary>
 	public static implicit operator ForceMagnitude<T>(Thrust<T> value) => ForceMagnitude<T>.Create(value.Value);
-/// <summary>Explicit conversion from ForceMagnitude.</summary>
+
+	/// <summary>Explicit conversion from ForceMagnitude.</summary>
 	public static explicit operator Thrust<T>(ForceMagnitude<T> value) => Create(value.Value);
-/// <summary>Creates a Thrust from a ForceMagnitude value.</summary>
+
+	/// <summary>Creates a Thrust from a ForceMagnitude value.</summary>
 	public static Thrust<T> From(ForceMagnitude<T> value) => Create(value.Value);
-/// <summary>Subtracts two Thrust values, returning the absolute difference as a non-negative Thrust.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Thrust<T> operator -(Thrust<T> left, Thrust<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Thrust values, returning the absolute difference as a non-negative Thrust.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Thrust<T> operator -(Thrust<T> left, Thrust<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TimeConstant.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TimeConstant.g.cs
index 34407977..0fc81115 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TimeConstant.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TimeConstant.g.cs
@@ -26,76 +26,90 @@ public partial record TimeConstant<T> : PhysicalQuantity<TimeConstant<T>, T>, IV
 	/// <returns>A new TimeConstant instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static TimeConstant<T> FromSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new TimeConstant from a value in Millisecond.
 	/// </summary>
 	/// <param name="value">The value in Millisecond.</param>
 	/// <returns>A new TimeConstant instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static TimeConstant<T> FromMillisecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new TimeConstant from a value in Microsecond.
 	/// </summary>
 	/// <param name="value">The value in Microsecond.</param>
 	/// <returns>A new TimeConstant instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static TimeConstant<T> FromMicrosecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new TimeConstant from a value in Minute.
 	/// </summary>
 	/// <param name="value">The value in Minute.</param>
 	/// <returns>A new TimeConstant instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static TimeConstant<T> FromMinute(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MinuteToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new TimeConstant from a value in Hour.
 	/// </summary>
 	/// <param name="value">The value in Hour.</param>
 	/// <returns>A new TimeConstant instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static TimeConstant<T> FromHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.HourToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new TimeConstant from a value in Day.
 	/// </summary>
 	/// <param name="value">The value in Day.</param>
 	/// <returns>A new TimeConstant instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static TimeConstant<T> FromDay(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DayToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new TimeConstant from a value in Year.
 	/// </summary>
 	/// <param name="value">The value in Year.</param>
 	/// <returns>A new TimeConstant instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static TimeConstant<T> FromYear(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YearToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new TimeConstant from a value in Week.
 	/// </summary>
 	/// <param name="value">The value in Week.</param>
 	/// <returns>A new TimeConstant instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static TimeConstant<T> FromWeek(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.WeekToSeconds)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new TimeConstant from a value in Nanosecond.
 	/// </summary>
 	/// <param name="value">The value in Nanosecond.</param>
 	/// <returns>A new TimeConstant instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static TimeConstant<T> FromNanosecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Time unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ITimeUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Duration.</summary>
+
+	/// <summary>Implicit conversion to Duration.</summary>
 	public static implicit operator Duration<T>(TimeConstant<T> value) => Duration<T>.Create(value.Value);
-/// <summary>Explicit conversion from Duration.</summary>
+
+	/// <summary>Explicit conversion from Duration.</summary>
 	public static explicit operator TimeConstant<T>(Duration<T> value) => Create(value.Value);
-/// <summary>Creates a TimeConstant from a Duration value.</summary>
+
+	/// <summary>Creates a TimeConstant from a Duration value.</summary>
 	public static TimeConstant<T> From(Duration<T> value) => Create(value.Value);
-/// <summary>Subtracts two TimeConstant values, returning the absolute difference as a non-negative TimeConstant.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static TimeConstant<T> operator -(TimeConstant<T> left, TimeConstant<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two TimeConstant values, returning the absolute difference as a non-negative TimeConstant.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static TimeConstant<T> operator -(TimeConstant<T> left, TimeConstant<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Torque1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Torque1D.g.cs
index a48a56ab..9b5257b3 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Torque1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Torque1D.g.cs
@@ -24,27 +24,32 @@ public partial record Torque1D<T> : PhysicalQuantity<Torque1D<T>, T>, IVector1<T
 	/// <param name="value">The value in NewtonMeter.</param>
 	/// <returns>A new <see cref="Torque1D{T}"/> instance.</returns>
 	public static Torque1D<T> FromNewtonMeter(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Torque1D{T}"/> from a value in PoundFoot.
 	/// </summary>
 	/// <param name="value">The value in PoundFoot.</param>
 	/// <returns>A new <see cref="Torque1D{T}"/> instance.</returns>
 	public static Torque1D<T> FromPoundFoot(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.PoundFootToNewtonMeters)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Torque unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ITorqueUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="TorqueMagnitude{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public TorqueMagnitude<T> Magnitude() => TorqueMagnitude<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Multiplies Torque1D by Duration to produce AngularMomentum1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularMomentum1D<T> operator *(Torque1D<T> left, Duration<T> right) => Multiply<AngularMomentum1D<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentum1D<T> operator *(Torque1D<T> left, Duration<T> right) => Multiply<AngularMomentum1D<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TorqueMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TorqueMagnitude.g.cs
index ee269146..d2951c80 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TorqueMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TorqueMagnitude.g.cs
@@ -25,40 +25,52 @@ public partial record TorqueMagnitude<T> : PhysicalQuantity<TorqueMagnitude<T>,
 	/// <returns>A new <see cref="TorqueMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static TorqueMagnitude<T> FromNewtonMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="TorqueMagnitude{T}"/> from a value in PoundFoot.
 	/// </summary>
 	/// <param name="value">The value in PoundFoot.</param>
 	/// <returns>A new <see cref="TorqueMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static TorqueMagnitude<T> FromPoundFoot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PoundFootToNewtonMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Torque unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ITorqueUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two TorqueMagnitude values, returning the absolute difference as a non-negative TorqueMagnitude.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static TorqueMagnitude<T> operator -(TorqueMagnitude<T> left, TorqueMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static TorqueMagnitude<T> operator -(TorqueMagnitude<T> left, TorqueMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies TorqueMagnitude by Angle to produce Energy.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Energy<T> operator *(TorqueMagnitude<T> left, Angle<T> right) => Multiply<Energy<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(TorqueMagnitude<T> left, Angle<T> right) => Multiply<Energy<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies TorqueMagnitude by Duration to produce AngularMomentumMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularMomentumMagnitude<T> operator *(TorqueMagnitude<T> left, Duration<T> right) => Multiply<AngularMomentumMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentumMagnitude<T> operator *(TorqueMagnitude<T> left, Duration<T> right) => Multiply<AngularMomentumMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides TorqueMagnitude by AngularAccelerationMagnitude to produce MomentOfInertia.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MomentOfInertia<T> operator /(TorqueMagnitude<T> left, AngularAccelerationMagnitude<T> right) => Divide<MomentOfInertia<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentOfInertia<T> operator /(TorqueMagnitude<T> left, AngularAccelerationMagnitude<T> right) => Divide<MomentOfInertia<T>>(left, right);
+
+	/// <summary>
 	/// Divides TorqueMagnitude by MomentOfInertia to produce AngularAccelerationMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AngularAccelerationMagnitude<T> operator /(TorqueMagnitude<T> left, MomentOfInertia<T> right) => Divide<AngularAccelerationMagnitude<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAccelerationMagnitude<T> operator /(TorqueMagnitude<T> left, MomentOfInertia<T> right) => Divide<AngularAccelerationMagnitude<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity1D.g.cs
index 47957ead..b0cc592d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity1D.g.cs
@@ -24,49 +24,59 @@ public partial record Velocity1D<T> : PhysicalQuantity<Velocity1D<T>, T>, IVecto
 	/// <param name="value">The value in MeterPerSecond.</param>
 	/// <returns>A new <see cref="Velocity1D{T}"/> instance.</returns>
 	public static Velocity1D<T> FromMeterPerSecond(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Velocity1D{T}"/> from a value in KilometerPerHour.
 	/// </summary>
 	/// <param name="value">The value in KilometerPerHour.</param>
 	/// <returns>A new <see cref="Velocity1D{T}"/> instance.</returns>
 	public static Velocity1D<T> FromKilometerPerHour(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.KilometerPerHourToMeterPerSecond)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Velocity1D{T}"/> from a value in MilePerHour.
 	/// </summary>
 	/// <param name="value">The value in MilePerHour.</param>
 	/// <returns>A new <see cref="Velocity1D{T}"/> instance.</returns>
 	public static Velocity1D<T> FromMilePerHour(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.MilePerHourToMeterPerSecond)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Velocity1D{T}"/> from a value in FootPerSecond.
 	/// </summary>
 	/// <param name="value">The value in FootPerSecond.</param>
 	/// <returns>A new <see cref="Velocity1D{T}"/> instance.</returns>
 	public static Velocity1D<T> FromFootPerSecond(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.FootPerSecondToMeterPerSecond)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Velocity1D{T}"/> from a value in Knot.
 	/// </summary>
 	/// <param name="value">The value in Knot.</param>
 	/// <returns>A new <see cref="Velocity1D{T}"/> instance.</returns>
 	public static Velocity1D<T> FromKnot(T value) => Create((value * T.CreateChecked(Units.ConversionConstants.KnotToMeterPerSecond)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Velocity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IVelocityUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="Speed{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public Speed<T> Magnitude() => Speed<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Multiplies Velocity1D by Duration to produce Displacement1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Displacement1D<T> operator *(Velocity1D<T> left, Duration<T> right) => Multiply<Displacement1D<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement1D<T> operator *(Velocity1D<T> left, Duration<T> right) => Multiply<Displacement1D<T>>(left, right);
+
+	/// <summary>
 	/// Divides Velocity1D by Duration to produce Acceleration1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Acceleration1D<T> operator /(Velocity1D<T> left, Duration<T> right) => Divide<Acceleration1D<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration1D<T> operator /(Velocity1D<T> left, Duration<T> right) => Divide<Acceleration1D<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Voltage.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Voltage.g.cs
index 711ed90c..c4cb449e 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Voltage.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Voltage.g.cs
@@ -24,31 +24,38 @@ public partial record Voltage<T> : PhysicalQuantity<Voltage<T>, T>, IVector1<Vol
 	/// <param name="value">The value in Volt.</param>
 	/// <returns>A new <see cref="Voltage{T}"/> instance.</returns>
 	public static Voltage<T> FromVolt(T value) => Create(value);
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Voltage{T}"/> from a value in Kilovolt.
 	/// </summary>
 	/// <param name="value">The value in Kilovolt.</param>
 	/// <returns>A new <see cref="Voltage{T}"/> instance.</returns>
 	public static Voltage<T> FromKilovolt(T value) => Create((value * T.CreateChecked(MetricMagnitudes.Kilo)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricPotential unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricPotentialUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Gets the magnitude of this quantity as a <see cref="VoltageMagnitude{T}"/>.
 	/// </summary>
 	/// <returns>The non-negative magnitude.</returns>
 	public VoltageMagnitude<T> Magnitude() => VoltageMagnitude<T>.Create(T.Abs(Value));
-/// <summary>
+
+	/// <summary>
 	/// Divides Voltage by Resistance to produce Current1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Current1D<T> operator /(Voltage<T> left, Resistance<T> right) => Divide<Current1D<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Current1D<T> operator /(Voltage<T> left, Resistance<T> right) => Divide<Current1D<T>>(left, right);
+
+	/// <summary>
 	/// Divides Voltage by Length to produce ElectricField1D.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ElectricField1D<T> operator /(Voltage<T> left, Length<T> right) => Divide<ElectricField1D<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ElectricField1D<T> operator /(Voltage<T> left, Length<T> right) => Divide<ElectricField1D<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VoltageDrop.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VoltageDrop.g.cs
index 70d40bde..70ac49d7 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VoltageDrop.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VoltageDrop.g.cs
@@ -26,27 +26,34 @@ public partial record VoltageDrop<T> : PhysicalQuantity<VoltageDrop<T>, T>, IVec
 	/// <returns>A new VoltageDrop instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static VoltageDrop<T> FromVolt(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new VoltageDrop from a value in Kilovolt.
 	/// </summary>
 	/// <param name="value">The value in Kilovolt.</param>
 	/// <returns>A new VoltageDrop instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static VoltageDrop<T> FromKilovolt(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricPotential unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricPotentialUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to VoltageMagnitude.</summary>
+
+	/// <summary>Implicit conversion to VoltageMagnitude.</summary>
 	public static implicit operator VoltageMagnitude<T>(VoltageDrop<T> value) => VoltageMagnitude<T>.Create(value.Value);
-/// <summary>Explicit conversion from VoltageMagnitude.</summary>
+
+	/// <summary>Explicit conversion from VoltageMagnitude.</summary>
 	public static explicit operator VoltageDrop<T>(VoltageMagnitude<T> value) => Create(value.Value);
-/// <summary>Creates a VoltageDrop from a VoltageMagnitude value.</summary>
+
+	/// <summary>Creates a VoltageDrop from a VoltageMagnitude value.</summary>
 	public static VoltageDrop<T> From(VoltageMagnitude<T> value) => Create(value.Value);
-/// <summary>Subtracts two VoltageDrop values, returning the absolute difference as a non-negative VoltageDrop.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static VoltageDrop<T> operator -(VoltageDrop<T> left, VoltageDrop<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two VoltageDrop values, returning the absolute difference as a non-negative VoltageDrop.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageDrop<T> operator -(VoltageDrop<T> left, VoltageDrop<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VoltageMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VoltageMagnitude.g.cs
index 86397b41..e46bcf0c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VoltageMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VoltageMagnitude.g.cs
@@ -25,64 +25,88 @@ public partial record VoltageMagnitude<T> : PhysicalQuantity<VoltageMagnitude<T>
 	/// <returns>A new <see cref="VoltageMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static VoltageMagnitude<T> FromVolt(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="VoltageMagnitude{T}"/> from a value in Kilovolt.
 	/// </summary>
 	/// <param name="value">The value in Kilovolt.</param>
 	/// <returns>A new <see cref="VoltageMagnitude{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static VoltageMagnitude<T> FromKilovolt(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-ElectricPotential unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IElectricPotentialUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two VoltageMagnitude values, returning the absolute difference as a non-negative VoltageMagnitude.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static VoltageMagnitude<T> operator -(VoltageMagnitude<T> left, VoltageMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator -(VoltageMagnitude<T> left, VoltageMagnitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Divides VoltageMagnitude by Resistance to produce CurrentMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static CurrentMagnitude<T> operator /(VoltageMagnitude<T> left, Resistance<T> right) => Divide<CurrentMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static CurrentMagnitude<T> operator /(VoltageMagnitude<T> left, Resistance<T> right) => Divide<CurrentMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides VoltageMagnitude by CurrentMagnitude to produce Resistance.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Resistance<T> operator /(VoltageMagnitude<T> left, CurrentMagnitude<T> right) => Divide<Resistance<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Resistance<T> operator /(VoltageMagnitude<T> left, CurrentMagnitude<T> right) => Divide<Resistance<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies VoltageMagnitude by CurrentMagnitude to produce Power.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Power<T> operator *(VoltageMagnitude<T> left, CurrentMagnitude<T> right) => Multiply<Power<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(VoltageMagnitude<T> left, CurrentMagnitude<T> right) => Multiply<Power<T>>(left, right);
+
+	/// <summary>
 	/// Divides VoltageMagnitude by Length to produce ElectricFieldMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ElectricFieldMagnitude<T> operator /(VoltageMagnitude<T> left, Length<T> right) => Divide<ElectricFieldMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ElectricFieldMagnitude<T> operator /(VoltageMagnitude<T> left, Length<T> right) => Divide<ElectricFieldMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Divides VoltageMagnitude by ElectricFieldMagnitude to produce Length.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Length<T> operator /(VoltageMagnitude<T> left, ElectricFieldMagnitude<T> right) => Divide<Length<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(VoltageMagnitude<T> left, ElectricFieldMagnitude<T> right) => Divide<Length<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies VoltageMagnitude by Capacitance to produce ChargeMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static ChargeMagnitude<T> operator *(VoltageMagnitude<T> left, Capacitance<T> right) => Multiply<ChargeMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ChargeMagnitude<T> operator *(VoltageMagnitude<T> left, Capacitance<T> right) => Multiply<ChargeMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies VoltageMagnitude by Conductance to produce CurrentMagnitude.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static CurrentMagnitude<T> operator *(VoltageMagnitude<T> left, Conductance<T> right) => Multiply<CurrentMagnitude<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static CurrentMagnitude<T> operator *(VoltageMagnitude<T> left, Conductance<T> right) => Multiply<CurrentMagnitude<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies VoltageMagnitude by Duration to produce MagneticFlux.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static MagneticFlux<T> operator *(VoltageMagnitude<T> left, Duration<T> right) => Multiply<MagneticFlux<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFlux<T> operator *(VoltageMagnitude<T> left, Duration<T> right) => Multiply<MagneticFlux<T>>(left, right);
+
+	/// <summary>
 	/// Divides VoltageMagnitude by Pressure to produce Sensitivity.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Sensitivity<T> operator /(VoltageMagnitude<T> left, Pressure<T> right) => Divide<Sensitivity<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Sensitivity<T> operator /(VoltageMagnitude<T> left, Pressure<T> right) => Divide<Sensitivity<T>>(left, right);
+
+	/// <summary>
 	/// Divides VoltageMagnitude by Sensitivity to produce Pressure.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Pressure<T> operator /(VoltageMagnitude<T> left, Sensitivity<T> right) => Divide<Pressure<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator /(VoltageMagnitude<T> left, Sensitivity<T> right) => Divide<Pressure<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Volume.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Volume.g.cs
index f369fa20..cb204a21 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Volume.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Volume.g.cs
@@ -25,119 +25,148 @@ public partial record Volume<T> : PhysicalQuantity<Volume<T>, T>, IVector0<Volum
 	/// <returns>A new <see cref="Volume{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Volume<T> FromCubicMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Volume{T}"/> from a value in Liter.
 	/// </summary>
 	/// <param name="value">The value in Liter.</param>
 	/// <returns>A new <see cref="Volume{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Volume<T> FromLiter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.LiterToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Volume{T}"/> from a value in Milliliter.
 	/// </summary>
 	/// <param name="value">The value in Milliliter.</param>
 	/// <returns>A new <see cref="Volume{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Volume<T> FromMilliliter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Volume{T}"/> from a value in CubicCentimeter.
 	/// </summary>
 	/// <param name="value">The value in CubicCentimeter.</param>
 	/// <returns>A new <see cref="Volume{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Volume<T> FromCubicCentimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.CubicCentimeterToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Volume{T}"/> from a value in CubicFoot.
 	/// </summary>
 	/// <param name="value">The value in CubicFoot.</param>
 	/// <returns>A new <see cref="Volume{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Volume<T> FromCubicFoot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.CubicFootToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Volume{T}"/> from a value in CubicInch.
 	/// </summary>
 	/// <param name="value">The value in CubicInch.</param>
 	/// <returns>A new <see cref="Volume{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Volume<T> FromCubicInch(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.CubicInchToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Volume{T}"/> from a value in Gallon.
 	/// </summary>
 	/// <param name="value">The value in Gallon.</param>
 	/// <returns>A new <see cref="Volume{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Volume<T> FromGallon(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.GallonToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Volume{T}"/> from a value in ImperialGallon.
 	/// </summary>
 	/// <param name="value">The value in ImperialGallon.</param>
 	/// <returns>A new <see cref="Volume{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Volume<T> FromImperialGallon(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.ImperialGallonToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Volume{T}"/> from a value in USQuart.
 	/// </summary>
 	/// <param name="value">The value in USQuart.</param>
 	/// <returns>A new <see cref="Volume{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Volume<T> FromUSQuart(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.USQuartToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Volume{T}"/> from a value in USPint.
 	/// </summary>
 	/// <param name="value">The value in USPint.</param>
 	/// <returns>A new <see cref="Volume{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Volume<T> FromUSPint(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.USPintToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="Volume{T}"/> from a value in USFluidOunce.
 	/// </summary>
 	/// <param name="value">The value in USFluidOunce.</param>
 	/// <returns>A new <see cref="Volume{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Volume<T> FromUSFluidOunce(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.USFluidOunceToCubicMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Volume unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IVolumeUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two Volume values, returning the absolute difference as a non-negative Volume.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Volume<T> operator -(Volume<T> left, Volume<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator -(Volume<T> left, Volume<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Divides Volume by Length to produce Area.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Area<T> operator /(Volume<T> left, Length<T> right) => Divide<Area<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator /(Volume<T> left, Length<T> right) => Divide<Area<T>>(left, right);
+
+	/// <summary>
 	/// Divides Volume by Area to produce Length.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Length<T> operator /(Volume<T> left, Area<T> right) => Divide<Length<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(Volume<T> left, Area<T> right) => Divide<Length<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Volume by Pressure to produce Energy.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Energy<T> operator *(Volume<T> left, Pressure<T> right) => Multiply<Energy<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Volume<T> left, Pressure<T> right) => Multiply<Energy<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Volume by Density to produce Mass.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Mass<T> operator *(Volume<T> left, Density<T> right) => Multiply<Mass<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator *(Volume<T> left, Density<T> right) => Multiply<Mass<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Volume by Concentration to produce AmountOfSubstance.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static AmountOfSubstance<T> operator *(Volume<T> left, Concentration<T> right) => Multiply<AmountOfSubstance<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator *(Volume<T> left, Concentration<T> right) => Multiply<AmountOfSubstance<T>>(left, right);
+
+	/// <summary>
 	/// Divides Volume by Duration to produce VolumetricFlowRate.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static VolumetricFlowRate<T> operator /(Volume<T> left, Duration<T> right) => Divide<VolumetricFlowRate<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VolumetricFlowRate<T> operator /(Volume<T> left, Duration<T> right) => Divide<VolumetricFlowRate<T>>(left, right);
+
+	/// <summary>
 	/// Divides Volume by VolumetricFlowRate to produce Duration.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Duration<T> operator /(Volume<T> left, VolumetricFlowRate<T> right) => Divide<Duration<T>>(left, right);
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Volume<T> left, VolumetricFlowRate<T> right) => Divide<Duration<T>>(left, right);
+
+	/// <summary>
 	/// Multiplies Volume by ElectricPowerDensity to produce Power.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Power<T> operator *(Volume<T> left, ElectricPowerDensity<T> right) => Multiply<Power<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(Volume<T> left, ElectricPowerDensity<T> right) => Multiply<Power<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VolumetricFlowRate.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VolumetricFlowRate.g.cs
index a26050ee..bce464a1 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VolumetricFlowRate.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VolumetricFlowRate.g.cs
@@ -25,28 +25,34 @@ public partial record VolumetricFlowRate<T> : PhysicalQuantity<VolumetricFlowRat
 	/// <returns>A new <see cref="VolumetricFlowRate{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static VolumetricFlowRate<T> FromCubicMeterPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new <see cref="VolumetricFlowRate{T}"/> from a value in LiterPerSecond.
 	/// </summary>
 	/// <param name="value">The value in LiterPerSecond.</param>
 	/// <returns>A new <see cref="VolumetricFlowRate{T}"/> instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static VolumetricFlowRate<T> FromLiterPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.LiterPerSecondToCubicMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-VolumetricFlowRate unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IVolumetricFlowRateUnit unit) => unit.FromBase(Value);
-/// <summary>
+
+	/// <summary>
 	/// Subtracts two VolumetricFlowRate values, returning the absolute difference as a non-negative VolumetricFlowRate.
 	/// Magnitude subtraction stays a magnitude (per the unified-vector model).
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static VolumetricFlowRate<T> operator -(VolumetricFlowRate<T> left, VolumetricFlowRate<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-/// <summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VolumetricFlowRate<T> operator -(VolumetricFlowRate<T> left, VolumetricFlowRate<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>
 	/// Multiplies VolumetricFlowRate by Duration to produce Volume.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Volume<T> operator *(VolumetricFlowRate<T> left, Duration<T> right) => Multiply<Volume<T>>(left, right);
-};
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(VolumetricFlowRate<T> left, Duration<T> right) => Multiply<Volume<T>>(left, right);
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Wavelength.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Wavelength.g.cs
index 1d1d1ede..750c7342 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Wavelength.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Wavelength.g.cs
@@ -26,97 +26,114 @@ public partial record Wavelength<T> : PhysicalQuantity<Wavelength<T>, T>, IVecto
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Wavelength<T> FromMeter(T value) => Create(Vector0Guards.EnsurePositive(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Wavelength from a value in Kilometer.
 	/// </summary>
 	/// <param name="value">The value in Kilometer.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Wavelength<T> FromKilometer(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Wavelength from a value in Centimeter.
 	/// </summary>
 	/// <param name="value">The value in Centimeter.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Wavelength<T> FromCentimeter(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Centi)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Wavelength from a value in Millimeter.
 	/// </summary>
 	/// <param name="value">The value in Millimeter.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Wavelength<T> FromMillimeter(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Wavelength from a value in Micrometer.
 	/// </summary>
 	/// <param name="value">The value in Micrometer.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Wavelength<T> FromMicrometer(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Wavelength from a value in Nanometer.
 	/// </summary>
 	/// <param name="value">The value in Nanometer.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Wavelength<T> FromNanometer(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Wavelength from a value in Angstrom.
 	/// </summary>
 	/// <param name="value">The value in Angstrom.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Wavelength<T> FromAngstrom(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.AngstromToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Wavelength from a value in Foot.
 	/// </summary>
 	/// <param name="value">The value in Foot.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Wavelength<T> FromFoot(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.FeetToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Wavelength from a value in Inch.
 	/// </summary>
 	/// <param name="value">The value in Inch.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Wavelength<T> FromInch(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.InchesToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Wavelength from a value in Yard.
 	/// </summary>
 	/// <param name="value">The value in Yard.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Wavelength<T> FromYard(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.YardToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Wavelength from a value in Mile.
 	/// </summary>
 	/// <param name="value">The value in Mile.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Wavelength<T> FromMile(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.MileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Wavelength from a value in NauticalMile.
 	/// </summary>
 	/// <param name="value">The value in NauticalMile.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Wavelength<T> FromNauticalMile(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.NauticalMileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Length unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Length.</summary>
+
+	/// <summary>Implicit conversion to Length.</summary>
 	public static implicit operator Length<T>(Wavelength<T> value) => Length<T>.Create(value.Value);
-/// <summary>Explicit conversion from Length.</summary>
+
+	/// <summary>Explicit conversion from Length.</summary>
 	public static explicit operator Wavelength<T>(Length<T> value) => Create(value.Value);
-/// <summary>Creates a Wavelength from a Length value.</summary>
+
+	/// <summary>Creates a Wavelength from a Length value.</summary>
 	public static Wavelength<T> From(Length<T> value) => Create(value.Value);
-/// <summary>Subtracts two Wavelength values, returning the absolute difference as a non-negative Wavelength.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Wavelength<T> operator -(Wavelength<T> left, Wavelength<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Wavelength values, returning the absolute difference as a non-negative Wavelength.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Wavelength<T> operator -(Wavelength<T> left, Wavelength<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Weight.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Weight.g.cs
index c9e357e4..b1b7dde0 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Weight.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Weight.g.cs
@@ -26,41 +26,50 @@ public partial record Weight<T> : PhysicalQuantity<Weight<T>, T>, IVector0<Weigh
 	/// <returns>A new Weight instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Weight<T> FromNewton(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Weight from a value in Kilonewton.
 	/// </summary>
 	/// <param name="value">The value in Kilonewton.</param>
 	/// <returns>A new Weight instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Weight<T> FromKilonewton(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Weight from a value in Dyne.
 	/// </summary>
 	/// <param name="value">The value in Dyne.</param>
 	/// <returns>A new Weight instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Weight<T> FromDyne(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DyneToNewtons)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Weight from a value in PoundForce.
 	/// </summary>
 	/// <param name="value">The value in PoundForce.</param>
 	/// <returns>A new Weight instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Weight<T> FromPoundForce(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PoundForceToNewtons)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Force unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IForceUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to ForceMagnitude.</summary>
+
+	/// <summary>Implicit conversion to ForceMagnitude.</summary>
 	public static implicit operator ForceMagnitude<T>(Weight<T> value) => ForceMagnitude<T>.Create(value.Value);
-/// <summary>Explicit conversion from ForceMagnitude.</summary>
+
+	/// <summary>Explicit conversion from ForceMagnitude.</summary>
 	public static explicit operator Weight<T>(ForceMagnitude<T> value) => Create(value.Value);
-/// <summary>Creates a Weight from a ForceMagnitude value.</summary>
+
+	/// <summary>Creates a Weight from a ForceMagnitude value.</summary>
 	public static Weight<T> From(ForceMagnitude<T> value) => Create(value.Value);
-/// <summary>Subtracts two Weight values, returning the absolute difference as a non-negative Weight.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Weight<T> operator -(Weight<T> left, Weight<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Weight values, returning the absolute difference as a non-negative Weight.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Weight<T> operator -(Weight<T> left, Weight<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Width.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Width.g.cs
index 7a9032cf..107550fb 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Width.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Width.g.cs
@@ -26,97 +26,114 @@ public partial record Width<T> : PhysicalQuantity<Width<T>, T>, IVector0<Width<T
 	/// <returns>A new Width instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Width<T> FromMeter(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Width from a value in Kilometer.
 	/// </summary>
 	/// <param name="value">The value in Kilometer.</param>
 	/// <returns>A new Width instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Width<T> FromKilometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Width from a value in Centimeter.
 	/// </summary>
 	/// <param name="value">The value in Centimeter.</param>
 	/// <returns>A new Width instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Width<T> FromCentimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Centi)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Width from a value in Millimeter.
 	/// </summary>
 	/// <param name="value">The value in Millimeter.</param>
 	/// <returns>A new Width instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Width<T> FromMillimeter(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Width from a value in Micrometer.
 	/// </summary>
 	/// <param name="value">The value in Micrometer.</param>
 	/// <returns>A new Width instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Width<T> FromMicrometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Width from a value in Nanometer.
 	/// </summary>
 	/// <param name="value">The value in Nanometer.</param>
 	/// <returns>A new Width instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Width<T> FromNanometer(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Width from a value in Angstrom.
 	/// </summary>
 	/// <param name="value">The value in Angstrom.</param>
 	/// <returns>A new Width instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Width<T> FromAngstrom(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AngstromToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Width from a value in Foot.
 	/// </summary>
 	/// <param name="value">The value in Foot.</param>
 	/// <returns>A new Width instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Width<T> FromFoot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FeetToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Width from a value in Inch.
 	/// </summary>
 	/// <param name="value">The value in Inch.</param>
 	/// <returns>A new Width instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Width<T> FromInch(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.InchesToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Width from a value in Yard.
 	/// </summary>
 	/// <param name="value">The value in Yard.</param>
 	/// <returns>A new Width instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Width<T> FromYard(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YardToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Width from a value in Mile.
 	/// </summary>
 	/// <param name="value">The value in Mile.</param>
 	/// <returns>A new Width instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Width<T> FromMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Width from a value in NauticalMile.
 	/// </summary>
 	/// <param name="value">The value in NauticalMile.</param>
 	/// <returns>A new Width instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Width<T> FromNauticalMile(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.NauticalMileToMeters)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Length unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Length.</summary>
+
+	/// <summary>Implicit conversion to Length.</summary>
 	public static implicit operator Length<T>(Width<T> value) => Length<T>.Create(value.Value);
-/// <summary>Explicit conversion from Length.</summary>
+
+	/// <summary>Explicit conversion from Length.</summary>
 	public static explicit operator Width<T>(Length<T> value) => Create(value.Value);
-/// <summary>Creates a Width from a Length value.</summary>
+
+	/// <summary>Creates a Width from a Length value.</summary>
 	public static Width<T> From(Length<T> value) => Create(value.Value);
-/// <summary>Subtracts two Width values, returning the absolute difference as a non-negative Width.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Width<T> operator -(Width<T> left, Width<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Width values, returning the absolute difference as a non-negative Width.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Width<T> operator -(Width<T> left, Width<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WindSpeed.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WindSpeed.g.cs
index 2fbb6f26..1cfefd0c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WindSpeed.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WindSpeed.g.cs
@@ -26,48 +26,58 @@ public partial record WindSpeed<T> : PhysicalQuantity<WindSpeed<T>, T>, IVector0
 	/// <returns>A new WindSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static WindSpeed<T> FromMeterPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new WindSpeed from a value in KilometerPerHour.
 	/// </summary>
 	/// <param name="value">The value in KilometerPerHour.</param>
 	/// <returns>A new WindSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static WindSpeed<T> FromKilometerPerHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilometerPerHourToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new WindSpeed from a value in MilePerHour.
 	/// </summary>
 	/// <param name="value">The value in MilePerHour.</param>
 	/// <returns>A new WindSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static WindSpeed<T> FromMilePerHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MilePerHourToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new WindSpeed from a value in FootPerSecond.
 	/// </summary>
 	/// <param name="value">The value in FootPerSecond.</param>
 	/// <returns>A new WindSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static WindSpeed<T> FromFootPerSecond(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FootPerSecondToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new WindSpeed from a value in Knot.
 	/// </summary>
 	/// <param name="value">The value in Knot.</param>
 	/// <returns>A new WindSpeed instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static WindSpeed<T> FromKnot(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KnotToMeterPerSecond)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Velocity unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IVelocityUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Speed.</summary>
+
+	/// <summary>Implicit conversion to Speed.</summary>
 	public static implicit operator Speed<T>(WindSpeed<T> value) => Speed<T>.Create(value.Value);
-/// <summary>Explicit conversion from Speed.</summary>
+
+	/// <summary>Explicit conversion from Speed.</summary>
 	public static explicit operator WindSpeed<T>(Speed<T> value) => Create(value.Value);
-/// <summary>Creates a WindSpeed from a Speed value.</summary>
+
+	/// <summary>Creates a WindSpeed from a Speed value.</summary>
 	public static WindSpeed<T> From(Speed<T> value) => Create(value.Value);
-/// <summary>Subtracts two WindSpeed values, returning the absolute difference as a non-negative WindSpeed.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static WindSpeed<T> operator -(WindSpeed<T> left, WindSpeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two WindSpeed values, returning the absolute difference as a non-negative WindSpeed.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static WindSpeed<T> operator -(WindSpeed<T> left, WindSpeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Work.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Work.g.cs
index f597096e..bd4223fc 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Work.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Work.g.cs
@@ -26,76 +26,90 @@ public partial record Work<T> : PhysicalQuantity<Work<T>, T>, IVector0<Work<T>,
 	/// <returns>A new Work instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Work<T> FromJoule(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Work from a value in Kilojoule.
 	/// </summary>
 	/// <param name="value">The value in Kilojoule.</param>
 	/// <returns>A new Work instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Work<T> FromKilojoule(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Work from a value in ElectronVolt.
 	/// </summary>
 	/// <param name="value">The value in ElectronVolt.</param>
 	/// <returns>A new Work instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Work<T> FromElectronVolt(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.ElectronVoltToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Work from a value in Calorie.
 	/// </summary>
 	/// <param name="value">The value in Calorie.</param>
 	/// <returns>A new Work instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Work<T> FromCalorie(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.CalorieToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Work from a value in Kilocalorie.
 	/// </summary>
 	/// <param name="value">The value in Kilocalorie.</param>
 	/// <returns>A new Work instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Work<T> FromKilocalorie(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilocalorieToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Work from a value in KilowattHour.
 	/// </summary>
 	/// <param name="value">The value in KilowattHour.</param>
 	/// <returns>A new Work instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Work<T> FromKilowattHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.KilowattHourToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Work from a value in WattHour.
 	/// </summary>
 	/// <param name="value">The value in WattHour.</param>
 	/// <returns>A new Work instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Work<T> FromWattHour(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.WattHourToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Work from a value in Erg.
 	/// </summary>
 	/// <param name="value">The value in Erg.</param>
 	/// <returns>A new Work instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Work<T> FromErg(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.ErgToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new Work from a value in Btu.
 	/// </summary>
 	/// <param name="value">The value in Btu.</param>
 	/// <returns>A new Work instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static Work<T> FromBtu(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.BtuToJoules)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Energy unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IEnergyUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Energy.</summary>
+
+	/// <summary>Implicit conversion to Energy.</summary>
 	public static implicit operator Energy<T>(Work<T> value) => Energy<T>.Create(value.Value);
-/// <summary>Explicit conversion from Energy.</summary>
+
+	/// <summary>Explicit conversion from Energy.</summary>
 	public static explicit operator Work<T>(Energy<T> value) => Create(value.Value);
-/// <summary>Creates a Work from a Energy value.</summary>
+
+	/// <summary>Creates a Work from a Energy value.</summary>
 	public static Work<T> From(Energy<T> value) => Create(value.Value);
-/// <summary>Subtracts two Work values, returning the absolute difference as a non-negative Work.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static Work<T> operator -(Work<T> left, Work<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two Work values, returning the absolute difference as a non-negative Work.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Work<T> operator -(Work<T> left, Work<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/YoungsModulus.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/YoungsModulus.g.cs
index 9316b537..7e6d486a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/YoungsModulus.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/YoungsModulus.g.cs
@@ -26,55 +26,66 @@ public partial record YoungsModulus<T> : PhysicalQuantity<YoungsModulus<T>, T>,
 	/// <returns>A new YoungsModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static YoungsModulus<T> FromPascal(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new YoungsModulus from a value in Kilopascal.
 	/// </summary>
 	/// <param name="value">The value in Kilopascal.</param>
 	/// <returns>A new YoungsModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static YoungsModulus<T> FromKilopascal(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new YoungsModulus from a value in Bar.
 	/// </summary>
 	/// <param name="value">The value in Bar.</param>
 	/// <returns>A new YoungsModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static YoungsModulus<T> FromBar(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.BarToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new YoungsModulus from a value in Atmosphere.
 	/// </summary>
 	/// <param name="value">The value in Atmosphere.</param>
 	/// <returns>A new YoungsModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static YoungsModulus<T> FromAtmosphere(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AtmosphereToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new YoungsModulus from a value in Psi.
 	/// </summary>
 	/// <param name="value">The value in Psi.</param>
 	/// <returns>A new YoungsModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static YoungsModulus<T> FromPsi(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.PsiToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Creates a new YoungsModulus from a value in Torr.
 	/// </summary>
 	/// <param name="value">The value in Torr.</param>
 	/// <returns>A new YoungsModulus instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
 	public static YoungsModulus<T> FromTorr(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.TorrToPascals)), nameof(value)));
-/// <summary>
+
+	/// <summary>
 	/// Converts this quantity's SI-base value to the value in <paramref name="unit"/>.
 	/// Cross-dimension calls (e.g. passing a non-Pressure unit) fail at compile time.
 	/// </summary>
 	/// <param name="unit">The dimensionally-compatible target unit.</param>
 	/// <returns>The value expressed in <paramref name="unit"/>.</returns>
 	public T In(global::ktsu.Semantics.Quantities.IPressureUnit unit) => unit.FromBase(Value);
-/// <summary>Implicit conversion to Pressure.</summary>
+
+	/// <summary>Implicit conversion to Pressure.</summary>
 	public static implicit operator Pressure<T>(YoungsModulus<T> value) => Pressure<T>.Create(value.Value);
-/// <summary>Explicit conversion from Pressure.</summary>
+
+	/// <summary>Explicit conversion from Pressure.</summary>
 	public static explicit operator YoungsModulus<T>(Pressure<T> value) => Create(value.Value);
-/// <summary>Creates a YoungsModulus from a Pressure value.</summary>
+
+	/// <summary>Creates a YoungsModulus from a Pressure value.</summary>
 	public static YoungsModulus<T> From(Pressure<T> value) => Create(value.Value);
-/// <summary>Subtracts two YoungsModulus values, returning the absolute difference as a non-negative YoungsModulus.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")] public static YoungsModulus<T> operator -(YoungsModulus<T> left, YoungsModulus<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
-};
+
+	/// <summary>Subtracts two YoungsModulus values, returning the absolute difference as a non-negative YoungsModulus.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static YoungsModulus<T> operator -(YoungsModulus<T> left, YoungsModulus<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+}
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.UnitsGenerator/Units.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.UnitsGenerator/Units.g.cs
index bc41b6ff..73ae11f0 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.UnitsGenerator/Units.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.UnitsGenerator/Units.g.cs
@@ -31,8 +31,7 @@ public sealed record Meter : IUnit, ILengthUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Meter() { }
-
-};
+}
 
 /// <summary>
 /// Kilometer - 1000 meters.
@@ -59,8 +58,7 @@ public sealed record Kilometer : IUnit, ILengthUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Kilometer() { }
-
-};
+}
 
 /// <summary>
 /// Centimeter - 0.01 meters.
@@ -87,8 +85,7 @@ public sealed record Centimeter : IUnit, ILengthUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Centimeter() { }
-
-};
+}
 
 /// <summary>
 /// Millimeter - 0.001 meters.
@@ -115,8 +112,7 @@ public sealed record Millimeter : IUnit, ILengthUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Millimeter() { }
-
-};
+}
 
 /// <summary>
 /// Foot - Imperial unit of length.
@@ -143,8 +139,7 @@ public sealed record Foot : IUnit, ILengthUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Foot() { }
-
-};
+}
 
 /// <summary>
 /// Inch - Imperial unit of length.
@@ -171,8 +166,7 @@ public sealed record Inch : IUnit, ILengthUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Inch() { }
-
-};
+}
 
 /// <summary>
 /// Micrometer - 0.000001 meters.
@@ -199,8 +193,7 @@ public sealed record Micrometer : IUnit, ILengthUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Micrometer() { }
-
-};
+}
 
 /// <summary>
 /// Nanometer - 0.000000001 meters.
@@ -227,8 +220,7 @@ public sealed record Nanometer : IUnit, ILengthUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Nanometer() { }
-
-};
+}
 
 /// <summary>
 /// Angstrom - 10⁻¹⁰ meters, used for atomic scales.
@@ -255,8 +247,7 @@ public sealed record Angstrom : IUnit, ILengthUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Angstrom() { }
-
-};
+}
 
 /// <summary>
 /// Yard - Imperial unit of length.
@@ -283,8 +274,7 @@ public sealed record Yard : IUnit, ILengthUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Yard() { }
-
-};
+}
 
 /// <summary>
 /// Mile - Imperial unit of length.
@@ -311,8 +301,7 @@ public sealed record Mile : IUnit, ILengthUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Mile() { }
-
-};
+}
 
 /// <summary>
 /// Kilogram - SI base unit of mass.
@@ -339,8 +328,7 @@ public sealed record Kilogram : IUnit, IMassUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Kilogram() { }
-
-};
+}
 
 /// <summary>
 /// Gram - 0.001 kilograms.
@@ -367,8 +355,7 @@ public sealed record Gram : IUnit, IMassUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Gram() { }
-
-};
+}
 
 /// <summary>
 /// Metric ton - 1000 kilograms.
@@ -395,8 +382,7 @@ public sealed record Ton : IUnit, IMassUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Ton() { }
-
-};
+}
 
 /// <summary>
 /// Pound - Imperial unit of mass.
@@ -423,8 +409,7 @@ public sealed record Pound : IUnit, IMassUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Pound() { }
-
-};
+}
 
 /// <summary>
 /// Ounce - Imperial unit of mass.
@@ -451,8 +436,7 @@ public sealed record Ounce : IUnit, IMassUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Ounce() { }
-
-};
+}
 
 /// <summary>
 /// Second - SI base unit of time.
@@ -479,8 +463,7 @@ public sealed record Second : IUnit, ITimeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Second() { }
-
-};
+}
 
 /// <summary>
 /// Minute - 60 seconds.
@@ -507,8 +490,7 @@ public sealed record Minute : IUnit, ITimeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Minute() { }
-
-};
+}
 
 /// <summary>
 /// Hour - 3600 seconds.
@@ -535,8 +517,7 @@ public sealed record Hour : IUnit, ITimeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Hour() { }
-
-};
+}
 
 /// <summary>
 /// Day - 86400 seconds.
@@ -563,8 +544,7 @@ public sealed record Day : IUnit, ITimeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Day() { }
-
-};
+}
 
 /// <summary>
 /// Year - 365.25 days (31557600 seconds).
@@ -591,8 +571,7 @@ public sealed record Year : IUnit, ITimeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Year() { }
-
-};
+}
 
 /// <summary>
 /// Millisecond - 0.001 seconds.
@@ -619,8 +598,7 @@ public sealed record Millisecond : IUnit, ITimeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Millisecond() { }
-
-};
+}
 
 /// <summary>
 /// Microsecond - 0.000001 seconds.
@@ -647,8 +625,7 @@ public sealed record Microsecond : IUnit, ITimeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Microsecond() { }
-
-};
+}
 
 /// <summary>
 /// Square meter - SI derived unit of area.
@@ -675,8 +652,7 @@ public sealed record SquareMeter : IUnit, IAreaUnit, INuclearCrossSectionUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public SquareMeter() { }
-
-};
+}
 
 /// <summary>
 /// Square foot - Imperial unit of area.
@@ -703,8 +679,7 @@ public sealed record SquareFoot : IUnit, IAreaUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public SquareFoot() { }
-
-};
+}
 
 /// <summary>
 /// Square inch - Imperial unit of area.
@@ -731,8 +706,7 @@ public sealed record SquareInch : IUnit, IAreaUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public SquareInch() { }
-
-};
+}
 
 /// <summary>
 /// Cubic meter - SI derived unit of volume.
@@ -759,8 +733,7 @@ public sealed record CubicMeter : IUnit, IVolumeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public CubicMeter() { }
-
-};
+}
 
 /// <summary>
 /// Liter - 0.001 cubic meters.
@@ -787,8 +760,7 @@ public sealed record Liter : IUnit, IVolumeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Liter() { }
-
-};
+}
 
 /// <summary>
 /// Milliliter - 0.001 liters.
@@ -815,8 +787,7 @@ public sealed record Milliliter : IUnit, IVolumeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Milliliter() { }
-
-};
+}
 
 /// <summary>
 /// US gallon - Imperial unit of volume.
@@ -843,8 +814,7 @@ public sealed record Gallon : IUnit, IVolumeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Gallon() { }
-
-};
+}
 
 /// <summary>
 /// Dimensionless - Pure number or ratio with no physical units.
@@ -871,8 +841,7 @@ public sealed record Dimensionless : IUnit, IDimensionlessUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Dimensionless() { }
-
-};
+}
 
 /// <summary>
 /// Radian - SI derived unit of plane angle.
@@ -899,8 +868,7 @@ public sealed record Radian : IUnit, IDimensionlessUnit, IAngularDisplacementUni
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Radian() { }
-
-};
+}
 
 /// <summary>
 /// Degree - Common unit of plane angle.
@@ -927,8 +895,7 @@ public sealed record Degree : IUnit, IDimensionlessUnit, IAngularDisplacementUni
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Degree() { }
-
-};
+}
 
 /// <summary>
 /// Nautical mile - 1852 meters, used in navigation.
@@ -955,8 +922,7 @@ public sealed record NauticalMile : IUnit, ILengthUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public NauticalMile() { }
-
-};
+}
 
 /// <summary>
 /// Stone - Imperial unit of mass (14 pounds).
@@ -983,8 +949,7 @@ public sealed record Stone : IUnit, IMassUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Stone() { }
-
-};
+}
 
 /// <summary>
 /// Short ton - US customary unit of mass (2000 pounds).
@@ -1011,8 +976,7 @@ public sealed record ShortTon : IUnit, IMassUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public ShortTon() { }
-
-};
+}
 
 /// <summary>
 /// Atomic mass unit - 1/12 the mass of a carbon-12 atom.
@@ -1039,8 +1003,7 @@ public sealed record AtomicMassUnit : IUnit, IMassUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public AtomicMassUnit() { }
-
-};
+}
 
 /// <summary>
 /// Week - 7 days.
@@ -1067,8 +1030,7 @@ public sealed record Week : IUnit, ITimeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Week() { }
-
-};
+}
 
 /// <summary>
 /// Nanosecond - 1e-9 seconds.
@@ -1095,8 +1057,7 @@ public sealed record Nanosecond : IUnit, ITimeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Nanosecond() { }
-
-};
+}
 
 /// <summary>
 /// Square kilometer - 1e6 square meters.
@@ -1123,8 +1084,7 @@ public sealed record SquareKilometer : IUnit, IAreaUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public SquareKilometer() { }
-
-};
+}
 
 /// <summary>
 /// Square centimeter - 1e-4 square meters.
@@ -1151,8 +1111,7 @@ public sealed record SquareCentimeter : IUnit, IAreaUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public SquareCentimeter() { }
-
-};
+}
 
 /// <summary>
 /// Square mile - Imperial unit of area.
@@ -1179,8 +1138,7 @@ public sealed record SquareMile : IUnit, IAreaUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public SquareMile() { }
-
-};
+}
 
 /// <summary>
 /// Hectare - metric unit of area (10000 m²).
@@ -1207,8 +1165,7 @@ public sealed record Hectare : IUnit, IAreaUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Hectare() { }
-
-};
+}
 
 /// <summary>
 /// Acre - Imperial unit of area.
@@ -1235,8 +1192,7 @@ public sealed record Acre : IUnit, IAreaUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Acre() { }
-
-};
+}
 
 /// <summary>
 /// Cubic centimeter - 1e-6 cubic meters.
@@ -1263,8 +1219,7 @@ public sealed record CubicCentimeter : IUnit, IVolumeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public CubicCentimeter() { }
-
-};
+}
 
 /// <summary>
 /// Cubic foot - Imperial unit of volume.
@@ -1291,8 +1246,7 @@ public sealed record CubicFoot : IUnit, IVolumeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public CubicFoot() { }
-
-};
+}
 
 /// <summary>
 /// Cubic inch - Imperial unit of volume.
@@ -1319,8 +1273,7 @@ public sealed record CubicInch : IUnit, IVolumeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public CubicInch() { }
-
-};
+}
 
 /// <summary>
 /// Imperial gallon - British unit of volume.
@@ -1347,8 +1300,7 @@ public sealed record ImperialGallon : IUnit, IVolumeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public ImperialGallon() { }
-
-};
+}
 
 /// <summary>
 /// US liquid quart - US customary unit of volume.
@@ -1375,8 +1327,7 @@ public sealed record USQuart : IUnit, IVolumeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public USQuart() { }
-
-};
+}
 
 /// <summary>
 /// US liquid pint - US customary unit of volume.
@@ -1403,8 +1354,7 @@ public sealed record USPint : IUnit, IVolumeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public USPint() { }
-
-};
+}
 
 /// <summary>
 /// US fluid ounce - US customary unit of volume.
@@ -1431,8 +1381,7 @@ public sealed record USFluidOunce : IUnit, IVolumeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public USFluidOunce() { }
-
-};
+}
 
 /// <summary>
 /// Gradian - 1/400 of a full circle (π/200 rad).
@@ -1459,8 +1408,7 @@ public sealed record Gradian : IUnit, IDimensionlessUnit, IAngularDisplacementUn
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Gradian() { }
-
-};
+}
 
 /// <summary>
 /// Revolution - one full circle (2π rad).
@@ -1487,8 +1435,7 @@ public sealed record Revolution : IUnit, IDimensionlessUnit, IAngularDisplacemen
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Revolution() { }
-
-};
+}
 
 /// <summary>
 /// Milliradian - 0.001 radians.
@@ -1515,8 +1462,7 @@ public sealed record Milliradian : IUnit, IDimensionlessUnit, IAngularDisplaceme
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Milliradian() { }
-
-};
+}
 
 /// <summary>
 /// Percent - one hundredth of unity.
@@ -1543,8 +1489,7 @@ public sealed record Percent : IUnit, IDimensionlessUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Percent() { }
-
-};
+}
 
 /// <summary>
 /// Parts per million - 1e-6 dimensionless ratio.
@@ -1571,8 +1516,7 @@ public sealed record PartPerMillion : IUnit, IDimensionlessUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public PartPerMillion() { }
-
-};
+}
 
 /// <summary>
 /// Parts per billion - 1e-9 dimensionless ratio.
@@ -1599,8 +1543,7 @@ public sealed record PartPerBillion : IUnit, IDimensionlessUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public PartPerBillion() { }
-
-};
+}
 
 /// <summary>
 /// Percent by weight - mass fraction expressed as a percentage.
@@ -1627,8 +1570,7 @@ public sealed record PercentByWeight : IUnit, IDimensionlessUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public PercentByWeight() { }
-
-};
+}
 
 /// <summary>
 /// Newton - SI derived unit of force.
@@ -1655,8 +1597,7 @@ public sealed record Newton : IUnit, IForceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Newton() { }
-
-};
+}
 
 /// <summary>
 /// Pascal - SI derived unit of pressure.
@@ -1683,8 +1624,7 @@ public sealed record Pascal : IUnit, IPressureUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Pascal() { }
-
-};
+}
 
 /// <summary>
 /// Meters per second - SI derived unit of velocity.
@@ -1711,8 +1651,7 @@ public sealed record MeterPerSecond : IUnit, IVelocityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public MeterPerSecond() { }
-
-};
+}
 
 /// <summary>
 /// Meters per second squared - SI derived unit of acceleration.
@@ -1739,8 +1678,7 @@ public sealed record MeterPerSecondSquared : IUnit, IAccelerationUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public MeterPerSecondSquared() { }
-
-};
+}
 
 /// <summary>
 /// Bar - Metric unit of pressure.
@@ -1767,8 +1705,7 @@ public sealed record Bar : IUnit, IPressureUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Bar() { }
-
-};
+}
 
 /// <summary>
 /// Standard atmosphere - Unit of pressure.
@@ -1795,8 +1732,7 @@ public sealed record Atmosphere : IUnit, IPressureUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Atmosphere() { }
-
-};
+}
 
 /// <summary>
 /// Pounds per square inch - Imperial unit of pressure.
@@ -1823,8 +1759,7 @@ public sealed record Psi : IUnit, IPressureUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Psi() { }
-
-};
+}
 
 /// <summary>
 /// Kilometers per hour - Common unit of velocity.
@@ -1851,8 +1786,7 @@ public sealed record KilometerPerHour : IUnit, IVelocityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public KilometerPerHour() { }
-
-};
+}
 
 /// <summary>
 /// Miles per hour - Imperial unit of velocity.
@@ -1879,8 +1813,7 @@ public sealed record MilePerHour : IUnit, IVelocityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public MilePerHour() { }
-
-};
+}
 
 /// <summary>
 /// Joule - SI derived unit of energy.
@@ -1907,8 +1840,7 @@ public sealed record Joule : IUnit, IEnergyUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Joule() { }
-
-};
+}
 
 /// <summary>
 /// Watt - SI derived unit of power.
@@ -1935,8 +1867,7 @@ public sealed record Watt : IUnit, IPowerUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Watt() { }
-
-};
+}
 
 /// <summary>
 /// Calorie - Thermochemical calorie, energy unit.
@@ -1963,8 +1894,7 @@ public sealed record Calorie : IUnit, IEnergyUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Calorie() { }
-
-};
+}
 
 /// <summary>
 /// Kilowatt-hour - Common unit of electrical energy.
@@ -1991,8 +1921,7 @@ public sealed record KilowattHour : IUnit, IEnergyUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public KilowattHour() { }
-
-};
+}
 
 /// <summary>
 /// Mechanical horsepower - Imperial unit of power.
@@ -2019,8 +1948,7 @@ public sealed record Horsepower : IUnit, IPowerUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Horsepower() { }
-
-};
+}
 
 /// <summary>
 /// Newton-second - SI derived unit of momentum.
@@ -2047,8 +1975,7 @@ public sealed record NewtonSecond : IUnit, IMomentumUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public NewtonSecond() { }
-
-};
+}
 
 /// <summary>
 /// Electron volt - Energy unit equal to electron charge times one volt.
@@ -2075,8 +2002,7 @@ public sealed record ElectronVolt : IUnit, IEnergyUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public ElectronVolt() { }
-
-};
+}
 
 /// <summary>
 /// Newton-meter - SI derived unit of torque.
@@ -2103,8 +2029,7 @@ public sealed record NewtonMeter : IUnit, ITorqueUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public NewtonMeter() { }
-
-};
+}
 
 /// <summary>
 /// Pound-foot - Imperial unit of torque.
@@ -2131,8 +2056,7 @@ public sealed record PoundFoot : IUnit, ITorqueUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public PoundFoot() { }
-
-};
+}
 
 /// <summary>
 /// Kilogram-meter squared - SI derived unit of moment of inertia.
@@ -2159,8 +2083,7 @@ public sealed record KilogramMeterSquared : IUnit, IMomentOfInertiaUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public KilogramMeterSquared() { }
-
-};
+}
 
 /// <summary>
 /// Kilogram-meter squared per second - SI derived unit of angular momentum.
@@ -2187,8 +2110,7 @@ public sealed record KilogramMeterSquaredPerSecond : IUnit, IAngularMomentumUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public KilogramMeterSquaredPerSecond() { }
-
-};
+}
 
 /// <summary>
 /// Meters per second cubed - SI derived unit of jerk.
@@ -2215,8 +2137,7 @@ public sealed record MeterPerSecondCubed : IUnit, IJerkUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public MeterPerSecondCubed() { }
-
-};
+}
 
 /// <summary>
 /// Meters per second to the fourth - SI derived unit of snap.
@@ -2243,8 +2164,7 @@ public sealed record MeterPerSecondQuartic : IUnit, ISnapUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public MeterPerSecondQuartic() { }
-
-};
+}
 
 /// <summary>
 /// Feet per second - Imperial unit of velocity.
@@ -2271,8 +2191,7 @@ public sealed record FootPerSecond : IUnit, IVelocityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public FootPerSecond() { }
-
-};
+}
 
 /// <summary>
 /// Knot - one nautical mile per hour.
@@ -2299,8 +2218,7 @@ public sealed record Knot : IUnit, IVelocityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Knot() { }
-
-};
+}
 
 /// <summary>
 /// Standard gravity - acceleration of free fall at Earth's surface.
@@ -2327,8 +2245,7 @@ public sealed record StandardGravity : IUnit, IAccelerationUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public StandardGravity() { }
-
-};
+}
 
 /// <summary>
 /// Kilonewton - 1000 newtons.
@@ -2355,8 +2272,7 @@ public sealed record Kilonewton : IUnit, IForceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Kilonewton() { }
-
-};
+}
 
 /// <summary>
 /// Dyne - CGS unit of force.
@@ -2383,8 +2299,7 @@ public sealed record Dyne : IUnit, IForceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Dyne() { }
-
-};
+}
 
 /// <summary>
 /// Pound-force - Imperial unit of force.
@@ -2411,8 +2326,7 @@ public sealed record PoundForce : IUnit, IForceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public PoundForce() { }
-
-};
+}
 
 /// <summary>
 /// Kilopascal - 1000 pascals.
@@ -2439,8 +2353,7 @@ public sealed record Kilopascal : IUnit, IPressureUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Kilopascal() { }
-
-};
+}
 
 /// <summary>
 /// Torr - 1/760 of a standard atmosphere.
@@ -2467,8 +2380,7 @@ public sealed record Torr : IUnit, IPressureUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Torr() { }
-
-};
+}
 
 /// <summary>
 /// Kilojoule - 1000 joules.
@@ -2495,8 +2407,7 @@ public sealed record Kilojoule : IUnit, IEnergyUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Kilojoule() { }
-
-};
+}
 
 /// <summary>
 /// Kilocalorie - 1000 thermochemical calories.
@@ -2523,8 +2434,7 @@ public sealed record Kilocalorie : IUnit, IEnergyUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Kilocalorie() { }
-
-};
+}
 
 /// <summary>
 /// Watt-hour - 3600 joules.
@@ -2551,8 +2461,7 @@ public sealed record WattHour : IUnit, IEnergyUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public WattHour() { }
-
-};
+}
 
 /// <summary>
 /// Erg - CGS unit of energy.
@@ -2579,8 +2488,7 @@ public sealed record Erg : IUnit, IEnergyUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Erg() { }
-
-};
+}
 
 /// <summary>
 /// British thermal unit (IT) - Imperial unit of energy.
@@ -2607,8 +2515,7 @@ public sealed record Btu : IUnit, IEnergyUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Btu() { }
-
-};
+}
 
 /// <summary>
 /// Kilowatt - 1000 watts.
@@ -2635,8 +2542,7 @@ public sealed record Kilowatt : IUnit, IPowerUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Kilowatt() { }
-
-};
+}
 
 /// <summary>
 /// Megawatt - 1e6 watts.
@@ -2663,8 +2569,7 @@ public sealed record Megawatt : IUnit, IPowerUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Megawatt() { }
-
-};
+}
 
 /// <summary>
 /// Watt per cubic meter - SI unit of volumetric power density.
@@ -2691,8 +2596,7 @@ public sealed record WattPerCubicMeter : IUnit, IElectricPowerDensityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public WattPerCubicMeter() { }
-
-};
+}
 
 /// <summary>
 /// Kelvin - SI base unit of thermodynamic temperature.
@@ -2719,8 +2623,7 @@ public sealed record Kelvin : IUnit, ITemperatureUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Kelvin() { }
-
-};
+}
 
 /// <summary>
 /// Celsius - Common temperature scale.
@@ -2747,8 +2650,7 @@ public sealed record Celsius : IUnit, ITemperatureUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Celsius() { }
-
-};
+}
 
 /// <summary>
 /// Fahrenheit - Imperial temperature scale.
@@ -2775,8 +2677,7 @@ public sealed record Fahrenheit : IUnit, ITemperatureUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Fahrenheit() { }
-
-};
+}
 
 /// <summary>
 /// Joule per kelvin - SI derived unit of entropy and heat capacity.
@@ -2803,8 +2704,7 @@ public sealed record JoulePerKelvin : IUnit, IEntropyUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public JoulePerKelvin() { }
-
-};
+}
 
 /// <summary>
 /// Joule per kilogram kelvin - SI derived unit of specific heat capacity.
@@ -2831,8 +2731,7 @@ public sealed record JoulePerKilogramKelvin : IUnit, ISpecificHeatUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public JoulePerKilogramKelvin() { }
-
-};
+}
 
 /// <summary>
 /// Watt per meter kelvin - SI derived unit of thermal conductivity.
@@ -2859,8 +2758,7 @@ public sealed record WattPerMeterKelvin : IUnit, IThermalConductivityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public WattPerMeterKelvin() { }
-
-};
+}
 
 /// <summary>
 /// Watt per square meter kelvin - SI derived unit of heat transfer coefficient.
@@ -2887,8 +2785,7 @@ public sealed record WattPerSquareMeterKelvin : IUnit, IHeatTransferCoefficientU
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public WattPerSquareMeterKelvin() { }
-
-};
+}
 
 /// <summary>
 /// Per kelvin - SI derived unit of thermal expansion coefficient.
@@ -2915,8 +2812,7 @@ public sealed record PerKelvin : IUnit, IThermalExpansionUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public PerKelvin() { }
-
-};
+}
 
 /// <summary>
 /// Rankine - absolute temperature scale with Fahrenheit-sized degrees.
@@ -2943,8 +2839,7 @@ public sealed record Rankine : IUnit, ITemperatureUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Rankine() { }
-
-};
+}
 
 /// <summary>
 /// Kelvin per watt - SI unit of absolute thermal resistance.
@@ -2971,8 +2866,7 @@ public sealed record KelvinPerWatt : IUnit, IThermalResistanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public KelvinPerWatt() { }
-
-};
+}
 
 /// <summary>
 /// Ampere - SI base unit of electric current.
@@ -2999,8 +2893,7 @@ public sealed record Ampere : IUnit, IElectricCurrentUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Ampere() { }
-
-};
+}
 
 /// <summary>
 /// Volt - SI derived unit of electric potential.
@@ -3027,8 +2920,7 @@ public sealed record Volt : IUnit, IElectricPotentialUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Volt() { }
-
-};
+}
 
 /// <summary>
 /// Volt per meter - SI derived unit of electric field strength.
@@ -3055,8 +2947,7 @@ public sealed record VoltPerMeter : IUnit, IElectricFieldUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public VoltPerMeter() { }
-
-};
+}
 
 /// <summary>
 /// Ohm - SI derived unit of electric resistance.
@@ -3083,8 +2974,7 @@ public sealed record Ohm : IUnit, IElectricResistanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Ohm() { }
-
-};
+}
 
 /// <summary>
 /// Coulomb - SI derived unit of electric charge.
@@ -3111,8 +3001,7 @@ public sealed record Coulomb : IUnit, IElectricChargeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Coulomb() { }
-
-};
+}
 
 /// <summary>
 /// Farad - SI derived unit of electric capacitance.
@@ -3139,8 +3028,7 @@ public sealed record Farad : IUnit, IElectricCapacitanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Farad() { }
-
-};
+}
 
 /// <summary>
 /// Siemens - SI derived unit of electric conductance.
@@ -3167,8 +3055,7 @@ public sealed record Siemens : IUnit, IElectricConductanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Siemens() { }
-
-};
+}
 
 /// <summary>
 /// Tesla - SI derived unit of magnetic flux density.
@@ -3195,8 +3082,7 @@ public sealed record Tesla : IUnit, IMagneticFluxDensityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Tesla() { }
-
-};
+}
 
 /// <summary>
 /// Gauss - CGS unit of magnetic flux density.
@@ -3223,8 +3109,7 @@ public sealed record Gauss : IUnit, IMagneticFluxDensityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Gauss() { }
-
-};
+}
 
 /// <summary>
 /// Weber - SI derived unit of magnetic flux.
@@ -3251,8 +3136,7 @@ public sealed record Weber : IUnit, IMagneticFluxUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Weber() { }
-
-};
+}
 
 /// <summary>
 /// Henry - SI derived unit of inductance.
@@ -3279,8 +3163,7 @@ public sealed record Henry : IUnit, IInductanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Henry() { }
-
-};
+}
 
 /// <summary>
 /// Milliampere - 0.001 amperes.
@@ -3307,8 +3190,7 @@ public sealed record Milliampere : IUnit, IElectricCurrentUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Milliampere() { }
-
-};
+}
 
 /// <summary>
 /// Kiloampere - 1000 amperes.
@@ -3335,8 +3217,7 @@ public sealed record Kiloampere : IUnit, IElectricCurrentUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Kiloampere() { }
-
-};
+}
 
 /// <summary>
 /// Kilovolt - 1000 volts.
@@ -3363,8 +3244,7 @@ public sealed record Kilovolt : IUnit, IElectricPotentialUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Kilovolt() { }
-
-};
+}
 
 /// <summary>
 /// Kilohm - 1000 ohms.
@@ -3391,8 +3271,7 @@ public sealed record Kilohm : IUnit, IElectricResistanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Kilohm() { }
-
-};
+}
 
 /// <summary>
 /// Megohm - 1e6 ohms.
@@ -3419,8 +3298,7 @@ public sealed record Megohm : IUnit, IElectricResistanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Megohm() { }
-
-};
+}
 
 /// <summary>
 /// Microfarad - 1e-6 farads.
@@ -3447,8 +3325,7 @@ public sealed record Microfarad : IUnit, IElectricCapacitanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Microfarad() { }
-
-};
+}
 
 /// <summary>
 /// Nanofarad - 1e-9 farads.
@@ -3475,8 +3352,7 @@ public sealed record Nanofarad : IUnit, IElectricCapacitanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Nanofarad() { }
-
-};
+}
 
 /// <summary>
 /// Picofarad - 1e-12 farads.
@@ -3503,8 +3379,7 @@ public sealed record Picofarad : IUnit, IElectricCapacitanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Picofarad() { }
-
-};
+}
 
 /// <summary>
 /// Ampere-hour - 3600 coulombs of electric charge.
@@ -3531,8 +3406,7 @@ public sealed record AmpereHour : IUnit, IElectricChargeUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public AmpereHour() { }
-
-};
+}
 
 /// <summary>
 /// Volt meter - SI unit of electric flux.
@@ -3559,8 +3433,7 @@ public sealed record VoltMeter : IUnit, IElectricFluxUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public VoltMeter() { }
-
-};
+}
 
 /// <summary>
 /// Farad per meter - SI unit of permittivity.
@@ -3587,8 +3460,7 @@ public sealed record FaradPerMeter : IUnit, IPermittivityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public FaradPerMeter() { }
-
-};
+}
 
 /// <summary>
 /// Siemens per meter - SI unit of electrical conductivity.
@@ -3615,8 +3487,7 @@ public sealed record SiemensPerMeter : IUnit, IElectricConductivityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public SiemensPerMeter() { }
-
-};
+}
 
 /// <summary>
 /// Volt per pascal - SI unit of transducer sensitivity.
@@ -3643,8 +3514,7 @@ public sealed record VoltPerPascal : IUnit, ISensitivityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public VoltPerPascal() { }
-
-};
+}
 
 /// <summary>
 /// Radians per second - SI derived unit of angular velocity.
@@ -3671,8 +3541,7 @@ public sealed record RadianPerSecond : IUnit, IAngularVelocityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public RadianPerSecond() { }
-
-};
+}
 
 /// <summary>
 /// Revolutions per minute - Common unit of angular velocity.
@@ -3699,8 +3568,7 @@ public sealed record RevolutionPerMinute : IUnit, IAngularVelocityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public RevolutionPerMinute() { }
-
-};
+}
 
 /// <summary>
 /// Radians per second squared - SI derived unit of angular acceleration.
@@ -3727,8 +3595,7 @@ public sealed record RadianPerSecondSquared : IUnit, IAngularAccelerationUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public RadianPerSecondSquared() { }
-
-};
+}
 
 /// <summary>
 /// Radians per second cubed - SI derived unit of angular jerk.
@@ -3755,8 +3622,7 @@ public sealed record RadianPerSecondCubed : IUnit, IAngularJerkUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public RadianPerSecondCubed() { }
-
-};
+}
 
 /// <summary>
 /// Hertz - SI derived unit of frequency.
@@ -3783,8 +3649,7 @@ public sealed record Hertz : IUnit, IFrequencyUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Hertz() { }
-
-};
+}
 
 /// <summary>
 /// Kilohertz - 1000 hertz.
@@ -3811,8 +3676,7 @@ public sealed record Kilohertz : IUnit, IFrequencyUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Kilohertz() { }
-
-};
+}
 
 /// <summary>
 /// Megahertz - 1e6 hertz.
@@ -3839,8 +3703,7 @@ public sealed record Megahertz : IUnit, IFrequencyUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Megahertz() { }
-
-};
+}
 
 /// <summary>
 /// Sone - psychoacoustic unit of perceived loudness.
@@ -3867,8 +3730,7 @@ public sealed record Sone : IUnit, ILoudnessUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Sone() { }
-
-};
+}
 
 /// <summary>
 /// Acum - psychoacoustic unit of perceived sharpness.
@@ -3895,8 +3757,7 @@ public sealed record Acum : IUnit, ISharpnessUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Acum() { }
-
-};
+}
 
 /// <summary>
 /// Candela - SI base unit of luminous intensity.
@@ -3923,8 +3784,7 @@ public sealed record Candela : IUnit, ILuminousIntensityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Candela() { }
-
-};
+}
 
 /// <summary>
 /// Lumen - SI derived unit of luminous flux.
@@ -3951,8 +3811,7 @@ public sealed record Lumen : IUnit, ILuminousFluxUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Lumen() { }
-
-};
+}
 
 /// <summary>
 /// Lux - SI derived unit of illuminance.
@@ -3979,8 +3838,7 @@ public sealed record Lux : IUnit, IIlluminanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Lux() { }
-
-};
+}
 
 /// <summary>
 /// Diopter - SI unit of optical power.
@@ -4007,8 +3865,7 @@ public sealed record Diopter : IUnit, IOpticalPowerUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Diopter() { }
-
-};
+}
 
 /// <summary>
 /// Millicandela - 0.001 candelas.
@@ -4035,8 +3892,7 @@ public sealed record Millicandela : IUnit, ILuminousIntensityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Millicandela() { }
-
-};
+}
 
 /// <summary>
 /// Foot-candle - Imperial unit of illuminance (lumen per square foot).
@@ -4063,8 +3919,7 @@ public sealed record FootCandle : IUnit, IIlluminanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public FootCandle() { }
-
-};
+}
 
 /// <summary>
 /// Candela per square meter - SI unit of luminance.
@@ -4091,8 +3946,7 @@ public sealed record CandelaPerSquareMeter : IUnit, ILuminanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public CandelaPerSquareMeter() { }
-
-};
+}
 
 /// <summary>
 /// Nit - common name for one candela per square meter.
@@ -4119,8 +3973,7 @@ public sealed record Nit : IUnit, ILuminanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Nit() { }
-
-};
+}
 
 /// <summary>
 /// Foot-lambert - Imperial unit of luminance (1/π candela per square foot).
@@ -4147,8 +4000,7 @@ public sealed record FootLambert : IUnit, ILuminanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public FootLambert() { }
-
-};
+}
 
 /// <summary>
 /// Becquerel - SI derived unit of radioactive activity.
@@ -4175,8 +4027,7 @@ public sealed record Becquerel : IUnit, IRadioactiveActivityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Becquerel() { }
-
-};
+}
 
 /// <summary>
 /// Gray - SI derived unit of absorbed dose.
@@ -4203,8 +4054,7 @@ public sealed record Gray : IUnit, IAbsorbedDoseUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Gray() { }
-
-};
+}
 
 /// <summary>
 /// Sievert - SI derived unit of equivalent dose.
@@ -4231,8 +4081,7 @@ public sealed record Sievert : IUnit, IEquivalentDoseUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Sievert() { }
-
-};
+}
 
 /// <summary>
 /// Barn - Unit of nuclear cross section.
@@ -4259,8 +4108,7 @@ public sealed record Barn : IUnit, INuclearCrossSectionUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Barn() { }
-
-};
+}
 
 /// <summary>
 /// Coulomb per kilogram - SI derived unit of radiation exposure.
@@ -4287,8 +4135,7 @@ public sealed record CoulombPerKilogram : IUnit, IExposureUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public CoulombPerKilogram() { }
-
-};
+}
 
 /// <summary>
 /// Curie - traditional unit of radioactive activity.
@@ -4315,8 +4162,7 @@ public sealed record Curie : IUnit, IRadioactiveActivityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Curie() { }
-
-};
+}
 
 /// <summary>
 /// Rad - traditional unit of absorbed dose (0.01 Gy).
@@ -4343,8 +4189,7 @@ public sealed record Rad : IUnit, IAbsorbedDoseUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Rad() { }
-
-};
+}
 
 /// <summary>
 /// Rem - traditional unit of equivalent dose (0.01 Sv).
@@ -4371,8 +4216,7 @@ public sealed record Rem : IUnit, IEquivalentDoseUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Rem() { }
-
-};
+}
 
 /// <summary>
 /// Roentgen - traditional unit of ionizing radiation exposure.
@@ -4399,8 +4243,7 @@ public sealed record Roentgen : IUnit, IExposureUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Roentgen() { }
-
-};
+}
 
 /// <summary>
 /// Kilogram per cubic meter - SI derived unit of density.
@@ -4427,8 +4270,7 @@ public sealed record KilogramPerCubicMeter : IUnit, IDensityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public KilogramPerCubicMeter() { }
-
-};
+}
 
 /// <summary>
 /// Gram per cubic centimeter - 1000 kg/m³.
@@ -4455,8 +4297,7 @@ public sealed record GramPerCubicCentimeter : IUnit, IDensityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public GramPerCubicCentimeter() { }
-
-};
+}
 
 /// <summary>
 /// Gram per liter - equal to one kilogram per cubic meter.
@@ -4483,8 +4324,7 @@ public sealed record GramPerLiter : IUnit, IDensityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public GramPerLiter() { }
-
-};
+}
 
 /// <summary>
 /// Mole - SI base unit of amount of substance.
@@ -4511,8 +4351,7 @@ public sealed record Mole : IUnit, IAmountOfSubstanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Mole() { }
-
-};
+}
 
 /// <summary>
 /// Mole per cubic meter - SI base unit of concentration.
@@ -4539,8 +4378,7 @@ public sealed record MolePerCubicMeter : IUnit, IConcentrationUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public MolePerCubicMeter() { }
-
-};
+}
 
 /// <summary>
 /// Molar - Moles per liter concentration.
@@ -4567,8 +4405,7 @@ public sealed record Molar : IUnit, IConcentrationUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Molar() { }
-
-};
+}
 
 /// <summary>
 /// Kilomole - 1000 moles.
@@ -4595,8 +4432,7 @@ public sealed record Kilomole : IUnit, IAmountOfSubstanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Kilomole() { }
-
-};
+}
 
 /// <summary>
 /// Millimole - 0.001 moles.
@@ -4623,8 +4459,7 @@ public sealed record Millimole : IUnit, IAmountOfSubstanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Millimole() { }
-
-};
+}
 
 /// <summary>
 /// Millimolar - 0.001 moles per liter (1 mol/m³).
@@ -4651,8 +4486,7 @@ public sealed record Millimolar : IUnit, IConcentrationUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Millimolar() { }
-
-};
+}
 
 /// <summary>
 /// Micromolar - 1e-6 moles per liter (0.001 mol/m³).
@@ -4679,8 +4513,7 @@ public sealed record Micromolar : IUnit, IConcentrationUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Micromolar() { }
-
-};
+}
 
 /// <summary>
 /// Square meter per second - SI derived unit of kinematic viscosity.
@@ -4707,8 +4540,7 @@ public sealed record SquareMeterPerSecond : IUnit, IKinematicViscosityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public SquareMeterPerSecond() { }
-
-};
+}
 
 /// <summary>
 /// Stokes - CGS unit of kinematic viscosity.
@@ -4735,8 +4567,7 @@ public sealed record Stokes : IUnit, IKinematicViscosityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Stokes() { }
-
-};
+}
 
 /// <summary>
 /// Pascal second - SI derived unit of dynamic viscosity.
@@ -4763,8 +4594,7 @@ public sealed record PascalSecond : IUnit, IDynamicViscosityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public PascalSecond() { }
-
-};
+}
 
 /// <summary>
 /// Poise - CGS unit of dynamic viscosity.
@@ -4791,8 +4621,7 @@ public sealed record Poise : IUnit, IDynamicViscosityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Poise() { }
-
-};
+}
 
 /// <summary>
 /// Cubic meter per second - SI derived unit of volumetric flow rate.
@@ -4819,8 +4648,7 @@ public sealed record CubicMeterPerSecond : IUnit, IVolumetricFlowRateUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public CubicMeterPerSecond() { }
-
-};
+}
 
 /// <summary>
 /// Liter per second - Common unit of volumetric flow rate.
@@ -4847,8 +4675,7 @@ public sealed record LiterPerSecond : IUnit, IVolumetricFlowRateUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public LiterPerSecond() { }
-
-};
+}
 
 /// <summary>
 /// Kilogram per second - SI derived unit of mass flow rate.
@@ -4875,8 +4702,7 @@ public sealed record KilogramPerSecond : IUnit, IMassFlowRateUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public KilogramPerSecond() { }
-
-};
+}
 
 /// <summary>
 /// Newton per meter - SI derived unit of surface tension.
@@ -4903,8 +4729,7 @@ public sealed record NewtonPerMeter : IUnit, ISurfaceTensionUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public NewtonPerMeter() { }
-
-};
+}
 
 /// <summary>
 /// Centipoise - 0.001 pascal seconds (viscosity of water at 20°C ≈ 1 cP).
@@ -4931,8 +4756,7 @@ public sealed record Centipoise : IUnit, IDynamicViscosityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Centipoise() { }
-
-};
+}
 
 /// <summary>
 /// Dyne per centimeter - CGS unit of surface tension.
@@ -4959,8 +4783,7 @@ public sealed record DynePerCentimeter : IUnit, ISurfaceTensionUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public DynePerCentimeter() { }
-
-};
+}
 
 /// <summary>
 /// Kilogram per mole - SI derived unit of molar mass.
@@ -4987,8 +4810,7 @@ public sealed record KilogramPerMole : IUnit, IMolarMassUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public KilogramPerMole() { }
-
-};
+}
 
 /// <summary>
 /// Gram per mole - Common unit of molar mass.
@@ -5015,8 +4837,7 @@ public sealed record GramPerMole : IUnit, IMolarMassUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public GramPerMole() { }
-
-};
+}
 
 /// <summary>
 /// Katal - SI derived unit of catalytic activity.
@@ -5043,8 +4864,7 @@ public sealed record Katal : IUnit, ICatalyticActivityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Katal() { }
-
-};
+}
 
 /// <summary>
 /// Mole per cubic meter second - SI derived unit of reaction rate.
@@ -5071,8 +4891,7 @@ public sealed record MolePerCubicMeterSecond : IUnit, IReactionRateUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public MolePerCubicMeterSecond() { }
-
-};
+}
 
 /// <summary>
 /// Joule per mole - SI derived unit of molar energy.
@@ -5099,8 +4918,7 @@ public sealed record JoulePerMole : IUnit, IMolarEnergyUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public JoulePerMole() { }
-
-};
+}
 
 /// <summary>
 /// Kilojoule per mole - Common unit of molar energy.
@@ -5127,8 +4945,7 @@ public sealed record KilojoulePerMole : IUnit, IMolarEnergyUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public KilojoulePerMole() { }
-
-};
+}
 
 /// <summary>
 /// Calorie per mole - thermochemical calorie per mole.
@@ -5155,8 +4972,7 @@ public sealed record CaloriePerMole : IUnit, IMolarEnergyUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public CaloriePerMole() { }
-
-};
+}
 
 /// <summary>
 /// Enzyme unit - one micromole of substrate per minute.
@@ -5183,8 +4999,7 @@ public sealed record EnzymeUnit : IUnit, ICatalyticActivityUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public EnzymeUnit() { }
-
-};
+}
 
 /// <summary>
 /// Dalton - molar mass numerically equal to one gram per mole.
@@ -5211,8 +5026,7 @@ public sealed record Dalton : IUnit, IMolarMassUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public Dalton() { }
-
-};
+}
 
 /// <summary>
 /// Per second - SI unit of a first-order rate constant.
@@ -5239,8 +5053,7 @@ public sealed record PerSecond : IUnit, IRateConstantUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public PerSecond() { }
-
-};
+}
 
 /// <summary>
 /// Watt per square meter - SI derived unit of irradiance and sound intensity.
@@ -5267,8 +5080,7 @@ public sealed record WattPerSquareMeter : IUnit, IIrradianceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public WattPerSquareMeter() { }
-
-};
+}
 
 /// <summary>
 /// Pascal second per meter - SI derived unit of acoustic impedance.
@@ -5295,14 +5107,14 @@ public sealed record PascalSecondPerMeter : IUnit, IAcousticImpedanceUnit
 
 	/// <summary>Initializes a new instance of the unit.</summary>
 	public PascalSecondPerMeter() { }
-
-};
+}
 
 /// <summary>
 /// Static catalogue exposing one singleton per declared unit. Generated quantity
 /// types accept these on their typed <c>In(...)</c> methods.
 /// </summary>
-public static class Units{
+public static class Units
+{
 	/// <summary>Singleton <c>Acre</c> instance.</summary>
 	public static readonly Acre Acre = new Acre();
 
@@ -5869,6 +5681,5 @@ public static class Units{
 
 	/// <summary>Singleton <c>Year</c> instance.</summary>
 	public static readonly Year Year = new Year();
-
-};
+}
 
diff --git a/Semantics.SourceGenerators/CodeGen/GeneratorBase.cs b/Semantics.SourceGenerators/CodeGen/GeneratorBase.cs
index 265585d5..8f28dbb5 100644
--- a/Semantics.SourceGenerators/CodeGen/GeneratorBase.cs
+++ b/Semantics.SourceGenerators/CodeGen/GeneratorBase.cs
@@ -9,7 +9,7 @@ namespace Semantics.SourceGenerators.CodeGen;
 using ktsu.CodeBlocker;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Text;
-using Semantics.SourceGenerators.Templates;
+using ktsu.CodeBlocker.Templates;
 
 /// <summary>
 /// Base class for a generator driven by one or more JSON metadata files supplied as
@@ -101,14 +101,9 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
 	/// <remarks>
 	/// A parameter rather than the literal this used to hard-code, so a consuming repository can
 	/// keep the header in step with its own file header template from one place.
-	/// <para>
-	/// Assembly-private only because <c>SourceFileTemplate</c> still lives in this project. Both
-	/// this and <see cref="WriteSourceFile"/> become <c>protected</c> once the template model comes
-	/// from <c>ktsu.CodeBlocker</c>, where it is already public.
-	/// </para>
 	/// </remarks>
 	/// <exception cref="ArgumentNullException"><paramref name="codeBlocker"/> is <see langword="null"/>.</exception>
-	private protected static void WriteFileHeader(CodeBlocker codeBlocker, string? copyright)
+	protected static void WriteFileHeader(CodeBlocker codeBlocker, string? copyright)
 	{
 		if (codeBlocker is null)
 		{
@@ -130,7 +125,7 @@ private protected static void WriteFileHeader(CodeBlocker codeBlocker, string? c
 	/// <param name="codeBlocker">The <see cref="CodeBlocker"/> to write to.</param>
 	/// <param name="sourceFileTemplate">The file to write.</param>
 	/// <param name="copyright">The copyright line, as for <see cref="WriteFileHeader"/>.</param>
-	private protected static void WriteSourceFile(CodeBlocker codeBlocker, SourceFileTemplate sourceFileTemplate, string? copyright)
+	protected static void WriteSourceFile(CodeBlocker codeBlocker, SourceFileTemplate sourceFileTemplate, string? copyright)
 	{
 		WriteFileHeader(codeBlocker, copyright);
 		codeBlocker.AddSourceFile(sourceFileTemplate);
diff --git a/Semantics.SourceGenerators/Generators/ConversionsGenerator.cs b/Semantics.SourceGenerators/Generators/ConversionsGenerator.cs
index 0150b73d..7568fbcf 100644
--- a/Semantics.SourceGenerators/Generators/ConversionsGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/ConversionsGenerator.cs
@@ -6,7 +6,8 @@ namespace Semantics.SourceGenerators;
 using Microsoft.CodeAnalysis;
 using Semantics.SourceGenerators.Models;
 using Semantics.SourceGenerators.CodeGen;
-using Semantics.SourceGenerators.Templates;
+using ktsu.CodeBlocker.Templates;
+using TypeKind = ktsu.CodeBlocker.Templates.TypeKind;
 
 /// <summary>
 /// Source generator that creates the ConversionConstants.cs file from JSON metadata.
@@ -32,18 +33,18 @@ protected override void Generate(SourceProductionContext context, ConversionsMet
 		ClassTemplate constantsClass = new()
 		{
 			Comments =
-			[
+			{
 				Emit.SummaryOpen,
 				"/// Conversion constants used by generated unit definitions.",
 				"/// Values sourced from conversions.json metadata.",
 				Emit.SummaryClose,
-			],
+			},
+			Kind = TypeKind.Class,
 			Keywords =
-			[
+			{
 				"internal",
 				Emit.Static,
-				"class",
-			],
+			},
 			Name = "ConversionConstants",
 		};
 
@@ -54,15 +55,15 @@ protected override void Generate(SourceProductionContext context, ConversionsMet
 				constantsClass.Members.Add(new FieldTemplate()
 				{
 					Comments =
-					[
+					{
 						$"/// <summary>{factor.Description}</summary>",
-					],
+					},
 					Keywords =
-					[
+					{
 						"internal",
 						"const",
 						"double",
-					],
+					},
 					Name = factor.Name,
 					DefaultValue = factor.Value,
 				});
diff --git a/Semantics.SourceGenerators/Generators/DimensionsGenerator.cs b/Semantics.SourceGenerators/Generators/DimensionsGenerator.cs
index 58b883c9..91649eb7 100644
--- a/Semantics.SourceGenerators/Generators/DimensionsGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/DimensionsGenerator.cs
@@ -8,7 +8,8 @@ namespace Semantics.SourceGenerators;
 using Microsoft.CodeAnalysis;
 using Semantics.SourceGenerators.Models;
 using Semantics.SourceGenerators.CodeGen;
-using Semantics.SourceGenerators.Templates;
+using ktsu.CodeBlocker.Templates;
+using TypeKind = ktsu.CodeBlocker.Templates.TypeKind;
 
 /// <summary>
 /// Source generator that creates the PhysicalDimensions.cs file from JSON metadata.
@@ -30,21 +31,22 @@ protected override void Generate(SourceProductionContext context, DimensionsMeta
 			FileName = "PhysicalDimensions.g.cs",
 			Namespace = "ktsu.Semantics.Quantities",
 			Usings =
-			[
+			{
 				"System.Collections.Generic",
-			],
+			},
 		};
 
 		// Generate DimensionInfo record
 		ClassTemplate dimensionInfoRecord = new()
 		{
 			Comments =
-			[
+			{
 				Emit.SummaryOpen,
 				"/// Dimension information record.",
 				Emit.SummaryClose,
-			],
-			Keywords = [Emit.Public, "record"],
+			},
+			Kind = TypeKind.Record,
+			Keywords = {Emit.Public},
 			Name = "DimensionInfo(string Name, string Symbol, Dictionary<string, int> DimensionalFormula, List<string> Quantities)",
 		};
 		sourceFileTemplate.Classes.Add(dimensionInfoRecord);
@@ -53,12 +55,13 @@ protected override void Generate(SourceProductionContext context, DimensionsMeta
 		ClassTemplate dimensionsClass = new()
 		{
 			Comments =
-			[
+			{
 				Emit.SummaryOpen,
 				"/// Static registry of physical dimensions.",
 				Emit.SummaryClose,
-			],
-			Keywords = [Emit.Public, Emit.Static, "class"],
+			},
+			Kind = TypeKind.Class,
+			Keywords = {Emit.Public, Emit.Static},
 			Name = "PhysicalDimensions",
 		};
 
@@ -103,8 +106,8 @@ protected override void Generate(SourceProductionContext context, DimensionsMeta
 
 			dimensionsClass.Members.Add(new FieldTemplate()
 			{
-				Comments = [$"/// <summary>{description}</summary>"],
-				Keywords = [Emit.Public, Emit.Static, "readonly", "DimensionInfo"],
+				Comments = {$"/// <summary>{description}</summary>"},
+				Keywords = {Emit.Public, Emit.Static, "readonly", "DimensionInfo"},
 				Name = dimension.Name,
 				DefaultValue = $"new(\"{dimension.Name}\", \"{dimension.Symbol}\", {formulaInit}, {quantitiesInit})",
 			});
@@ -114,8 +117,8 @@ protected override void Generate(SourceProductionContext context, DimensionsMeta
 		string allDimensions = string.Join(", ", sortedDimensions.Select(d => d.Name));
 		dimensionsClass.Members.Add(new FieldTemplate()
 		{
-			Comments = ["/// <summary>Gets a frozen collection of all standard physical dimensions.</summary>"],
-			Keywords = [Emit.Public, Emit.Static, "IReadOnlySet<DimensionInfo>"],
+			Comments = {"/// <summary>Gets a frozen collection of all standard physical dimensions.</summary>"},
+			Keywords = {Emit.Public, Emit.Static, "IReadOnlySet<DimensionInfo>"},
 			Name = "All",
 			DefaultValue = $"new HashSet<DimensionInfo>([ {allDimensions} ])",
 		});
@@ -124,19 +127,23 @@ protected override void Generate(SourceProductionContext context, DimensionsMeta
 
 		// Emit per-dimension marker interfaces (I{Dim}Unit : IUnit) so generated
 		// quantity types can accept dimensionally-compatible units only.
-		sourceFileTemplate.Classes.AddRange(sortedDimensions.Select(dimension => new ClassTemplate()
+		foreach (PhysicalDimension dimension in sortedDimensions)
 		{
-			Comments =
-			[
-				Emit.SummaryOpen,
-				$"/// Marker interface implemented by every unit of the <c>{dimension.Name}</c> dimension.",
-				"/// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.",
-				Emit.SummaryClose,
-			],
-			Keywords = [Emit.Public, "interface"],
-			Name = $"I{dimension.Name}Unit",
-			Interfaces = ["IUnit"],
-		}));
+			sourceFileTemplate.Classes.Add(new ClassTemplate
+			{
+				Comments =
+				{
+					Emit.SummaryOpen,
+					$"/// Marker interface implemented by every unit of the <c>{dimension.Name}</c> dimension.",
+					"/// Generated quantities use this to make <c>In(...)</c> dimensionally type-safe at compile time.",
+					Emit.SummaryClose,
+				},
+				Kind = TypeKind.Interface,
+				Keywords = {Emit.Public},
+				Name = $"I{dimension.Name}Unit",
+				Interfaces = {"IUnit"},
+			});
+		}
 
 		WriteSourceFileTo(codeBlocker, sourceFileTemplate);
 		GeneratedSource.Add(context, sourceFileTemplate.FileName, codeBlocker.ToString());
diff --git a/Semantics.SourceGenerators/Generators/LogarithmicScalesGenerator.cs b/Semantics.SourceGenerators/Generators/LogarithmicScalesGenerator.cs
index 888138e8..0d383063 100644
--- a/Semantics.SourceGenerators/Generators/LogarithmicScalesGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/LogarithmicScalesGenerator.cs
@@ -135,8 +135,8 @@ private static void WriteConversion(CodeBlocker cb, LogarithmicScaleDefinition s
 		string ratioExpr = referenceExpr == null ? "linearValue" : "linearValue / reference";
 		string logExpr = logBase switch
 		{
-			"10.0" => $"Math.Log10({ratioExpr})",
-			"2.0" => $"Math.Log2({ratioExpr})",
+			"10.0"=> $"Math.Log10({ratioExpr})",
+			"2.0"=> $"Math.Log2({ratioExpr})",
 			_ => $"Math.Log({ratioExpr}, {logBase})",
 		};
 
diff --git a/Semantics.SourceGenerators/Generators/MagnitudesGenerator.cs b/Semantics.SourceGenerators/Generators/MagnitudesGenerator.cs
index 103c84d7..0073bed9 100644
--- a/Semantics.SourceGenerators/Generators/MagnitudesGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/MagnitudesGenerator.cs
@@ -6,7 +6,8 @@ namespace Semantics.SourceGenerators;
 using Microsoft.CodeAnalysis;
 using Semantics.SourceGenerators.Models;
 using Semantics.SourceGenerators.CodeGen;
-using Semantics.SourceGenerators.Templates;
+using ktsu.CodeBlocker.Templates;
+using TypeKind = ktsu.CodeBlocker.Templates.TypeKind;
 
 /// <summary>
 /// Source generator that creates the MetricMagnitudes.cs file from JSON metadata.
@@ -32,12 +33,13 @@ protected override void Generate(SourceProductionContext context, MagnitudesMeta
 		ClassTemplate magnitudesClass = new()
 		{
 			Comments =
-			[
+			{
 				Emit.SummaryOpen,
 				"/// Metric magnitude constants for unit scaling.",
 				Emit.SummaryClose,
-			],
-			Keywords = [Emit.Public, Emit.Static, "class"],
+			},
+			Kind = TypeKind.Class,
+			Keywords = {Emit.Public, Emit.Static},
 			Name = "MetricMagnitudes",
 		};
 
@@ -51,8 +53,8 @@ protected override void Generate(SourceProductionContext context, MagnitudesMeta
 
 			magnitudesClass.Members.Add(new FieldTemplate()
 			{
-				Comments = [$"/// <summary>{magnitude.Name} magnitude ({magnitude.Symbol}): 10^{magnitude.Exponent}</summary>"],
-				Keywords = [Emit.Public, "const", "double"],
+				Comments = {$"/// <summary>{magnitude.Name} magnitude ({magnitude.Symbol}): 10^{magnitude.Exponent}</summary>"},
+				Keywords = {Emit.Public, "const", "double"},
 				Name = magnitude.Name,
 				DefaultValue = valueString,
 			});
diff --git a/Semantics.SourceGenerators/Generators/PhysicalConstantsGenerator.cs b/Semantics.SourceGenerators/Generators/PhysicalConstantsGenerator.cs
index 9ae254de..2eed239e 100644
--- a/Semantics.SourceGenerators/Generators/PhysicalConstantsGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/PhysicalConstantsGenerator.cs
@@ -8,7 +8,8 @@ namespace Semantics.SourceGenerators;
 using Microsoft.CodeAnalysis;
 using Semantics.SourceGenerators.Models;
 using Semantics.SourceGenerators.CodeGen;
-using Semantics.SourceGenerators.Templates;
+using ktsu.CodeBlocker.Templates;
+using TypeKind = ktsu.CodeBlocker.Templates.TypeKind;
 
 /// <summary>
 /// Source generator that creates the PhysicalConstants.cs file from JSON metadata.
@@ -58,22 +59,23 @@ protected override void Generate(SourceProductionContext context, DomainsMetadat
 			FileName = "PhysicalConstants.g.cs",
 			Namespace = "ktsu.Semantics.Quantities",
 			Usings =
-			[
+			{
 				"System.Globalization",
 				"System.Numerics",
-			],
+			},
 		};
 
 		ClassTemplate constantsClass = new()
 		{
 			Comments =
-			[
+			{
 				Emit.SummaryOpen,
 				"/// Provides fundamental physical constants used throughout the Semantics library.",
 				"/// All values are based on the 2019 redefinition of SI base units and CODATA 2018 values.",
 				Emit.SummaryClose,
-			],
-			Keywords = [Emit.Public, Emit.Static, "class"],
+			},
+			Kind = TypeKind.Class,
+			Keywords = {Emit.Public, Emit.Static},
 			Name = "PhysicalConstants",
 		};
 
@@ -88,12 +90,13 @@ protected override void Generate(SourceProductionContext context, DomainsMetadat
 			ClassTemplate domainClass = new()
 			{
 				Comments =
-				[
+				{
 					Emit.SummaryOpen,
 					$"/// {domain.Description}",
 					Emit.SummaryClose,
-				],
-				Keywords = [Emit.Public, Emit.Static, "class"],
+				},
+				Kind = TypeKind.Class,
+			Keywords = {Emit.Public, Emit.Static},
 				Name = domain.Name,
 			};
 
@@ -101,30 +104,31 @@ protected override void Generate(SourceProductionContext context, DomainsMetadat
 			ClassTemplate holderClass = new()
 			{
 				Comments =
-				[
+				{
 					Emit.SummaryOpen,
 					$"/// Caches the {domain.Name} constants materialised into <typeparamref name=\"T\"/>.",
 					Emit.SummaryClose,
-				],
-				Keywords = ["private", Emit.Static, "class"],
+				},
+				Kind = TypeKind.Class,
+			Keywords = {"private", Emit.Static},
 				Name = $"{HolderName}<T>",
-				Constraints = [NumericConstraint],
+				Constraints = {NumericConstraint},
 			};
 
 			foreach (ConstantDefinition constant in domain.Constants.OrderBy(c => c.Name))
 			{
 				domainClass.Members.Add(new MethodTemplate()
 				{
-					Comments = [$"/// <summary>{constant.Description}</summary>"],
-					Keywords = [Emit.Public, Emit.Static, "T"],
+					Comments = {$"/// <summary>{constant.Description}</summary>"},
+					Keywords = {Emit.Public, Emit.Static, "T"},
 					Name = $"{constant.Name}<T>",
 					BodyFactory = (body) => body.Write($" {NumericConstraint} => {HolderName}<T>.{constant.Name};"),
 				});
 
 				holderClass.Members.Add(new FieldTemplate()
 				{
-					Comments = [$"/// <summary>{constant.Description}</summary>"],
-					Keywords = ["internal", Emit.Static, "readonly", "T"],
+					Comments = {$"/// <summary>{constant.Description}</summary>"},
+					Keywords = {"internal", Emit.Static, "readonly", "T"},
 					Name = constant.Name,
 					DefaultValue = $"T.Parse(\"{constant.Value}\", {ParseStyles}, CultureInfo.InvariantCulture)",
 				});
@@ -144,12 +148,13 @@ protected override void Generate(SourceProductionContext context, DomainsMetadat
 			ClassTemplate genericClass = new()
 			{
 				Comments =
-				[
+				{
 					Emit.SummaryOpen,
 					"/// Helper methods to get constants as generic numeric types.",
 					Emit.SummaryClose,
-				],
-				Keywords = [Emit.Public, Emit.Static, "class"],
+				},
+				Kind = TypeKind.Class,
+			Keywords = {Emit.Public, Emit.Static},
 				Name = "Generic",
 			};
 
@@ -162,8 +167,8 @@ protected override void Generate(SourceProductionContext context, DomainsMetadat
 
 				genericClass.Members.Add(new MethodTemplate()
 				{
-					Comments = [$"/// <summary>Gets {constant.Description.ToLowerInvariant()} as type T.</summary>"],
-					Keywords = [Emit.Public, Emit.Static, "T"],
+					Comments = {$"/// <summary>Gets {constant.Description.ToLowerInvariant()} as type T.</summary>"},
+					Keywords = {Emit.Public, Emit.Static, "T"},
 					Name = $"{constant.Name}<T>",
 					BodyFactory = (body) => body.Write($" {NumericConstraint} => {domainName}.{constant.Name}<T>();"),
 				});
diff --git a/Semantics.SourceGenerators/Generators/PrecisionGenerator.cs b/Semantics.SourceGenerators/Generators/PrecisionGenerator.cs
index f07afaaa..8755673e 100644
--- a/Semantics.SourceGenerators/Generators/PrecisionGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/PrecisionGenerator.cs
@@ -7,7 +7,8 @@ namespace Semantics.SourceGenerators;
 using Microsoft.CodeAnalysis;
 using Semantics.SourceGenerators.Models;
 using Semantics.SourceGenerators.CodeGen;
-using Semantics.SourceGenerators.Templates;
+using ktsu.CodeBlocker.Templates;
+using TypeKind = ktsu.CodeBlocker.Templates.TypeKind;
 
 /// <summary>
 /// Source generator that creates the StorageTypes.cs file from JSON metadata.
@@ -29,21 +30,22 @@ protected override void Generate(SourceProductionContext context, PrecisionMetad
 			FileName = "StorageTypes.g.cs",
 			Namespace = "ktsu.Semantics.Quantities",
 			Usings =
-			[
+			{
 				"System",
 				"System.Collections.Generic",
-			],
+			},
 		};
 
 		ClassTemplate storageClass = new()
 		{
 			Comments =
-			[
+			{
 				Emit.SummaryOpen,
 				"/// Available storage types for numeric values in the Semantics library.",
 				Emit.SummaryClose,
-			],
-			Keywords = [Emit.Public, Emit.Static, "class"],
+			},
+			Kind = TypeKind.Class,
+			Keywords = {Emit.Public, Emit.Static},
 			Name = "StorageTypes",
 		};
 
@@ -52,8 +54,8 @@ protected override void Generate(SourceProductionContext context, PrecisionMetad
 		{
 			storageClass.Members.Add(new FieldTemplate()
 			{
-				Comments = [$"/// <summary>The {storageType} storage type.</summary>"],
-				Keywords = [Emit.Public, Emit.Static, "readonly", "Type"],
+				Comments = {$"/// <summary>The {storageType} storage type.</summary>"},
+				Keywords = {Emit.Public, Emit.Static, "readonly", "Type"},
 				Name = storageType.ToUpperInvariant(),
 				DefaultValue = $"typeof({storageType})",
 			});
@@ -63,8 +65,8 @@ protected override void Generate(SourceProductionContext context, PrecisionMetad
 		string allTypes = string.Join(", ", metadata.StorageTypes.OrderBy(t => t).Select(t => t.ToUpperInvariant()));
 		storageClass.Members.Add(new FieldTemplate()
 		{
-			Comments = ["/// <summary>Gets all available storage types.</summary>"],
-			Keywords = [Emit.Public, Emit.Static, "readonly", "IReadOnlyList<Type>"],
+			Comments = {"/// <summary>Gets all available storage types.</summary>"},
+			Keywords = {Emit.Public, Emit.Static, "readonly", "IReadOnlyList<Type>"},
 			Name = "All",
 			DefaultValue = $"new List<Type> {{ {allTypes} }}",
 		});
@@ -73,8 +75,8 @@ protected override void Generate(SourceProductionContext context, PrecisionMetad
 		string allNames = string.Join(", ", metadata.StorageTypes.OrderBy(t => t).Select(t => $"\"{t}\""));
 		storageClass.Members.Add(new FieldTemplate()
 		{
-			Comments = ["/// <summary>Gets the names of all available storage types.</summary>"],
-			Keywords = [Emit.Public, Emit.Static, "readonly", "IReadOnlyList<string>"],
+			Comments = {"/// <summary>Gets the names of all available storage types.</summary>"},
+			Keywords = {Emit.Public, Emit.Static, "readonly", "IReadOnlyList<string>"},
 			Name = "Names",
 			DefaultValue = $"new List<string> {{ {allNames} }}",
 		});
diff --git a/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs b/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
index 0aa156d9..5c26cdd3 100644
--- a/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
@@ -10,7 +10,8 @@ namespace Semantics.SourceGenerators;
 using Microsoft.CodeAnalysis;
 using Semantics.SourceGenerators.CodeGen;
 using Semantics.SourceGenerators.Models;
-using Semantics.SourceGenerators.Templates;
+using ktsu.CodeBlocker.Templates;
+using TypeKind = ktsu.CodeBlocker.Templates.TypeKind;
 
 /// <summary>
 /// Source generator that creates quantity types from the unified vector schema in dimensions.json.
@@ -686,8 +687,8 @@ private static void AddUnitFactories(
 				: BuildToBaseExpression(unitName, unitMap);
 
 			string body = applyV0Guard
-				? $" => Create(Vector0Guards.{guardMethod}({conversionExpr}, nameof(value)));"
-				: $" => Create({conversionExpr});";
+				? $"=> Create(Vector0Guards.{guardMethod}({conversionExpr}, nameof(value)));"
+				: $"=> Create({conversionExpr});";
 
 			// Issue #49: factory names are the unit's singular lemma — the unit name verbatim
 			// (e.g. From{Meter}, From{Kilogram}, From{MeterPerSecond}). units.json carries the
@@ -710,12 +711,11 @@ private static void AddUnitFactories(
 
 			cls.Members.Add(new MethodTemplate()
 			{
-				Comments = comments,
-				Keywords = [Emit.Public, Emit.Static, fullType],
+				Keywords = {Emit.Public, Emit.Static, fullType},
 				Name = $"From{factorySuffix}",
-				Parameters = [new ParameterTemplate { Type = "T", Name = Emit.ValueParameter }],
+				Parameters = {new ParameterTemplate { Type = "T", Name = Emit.ValueParameter }},
 				BodyFactory = (b) => b.Write(body),
-			});
+			}.WithComments(comments));
 		}
 	}
 
@@ -768,29 +768,29 @@ private static void AddDimensionAndInMembers(ClassTemplate cls, PhysicalDimensio
 	{
 		cls.Members.Add(new FieldTemplate()
 		{
-			Comments = [$"/// <summary>Gets the physical dimension this quantity belongs to.</summary>"],
-			Keywords = [Emit.Public, "override", "DimensionInfo"],
+			Comments = {$"/// <summary>Gets the physical dimension this quantity belongs to.</summary>"},
+			Keywords = {Emit.Public, "override", "DimensionInfo"},
 			Name = $"Dimension => PhysicalDimensions.{dim.Name}",
 		});
 
 		cls.Members.Add(new MethodTemplate()
 		{
 			Comments =
-			[
+			{
 				Emit.SummaryOpen,
 				$"/// Converts this quantity's SI-base value to the value in <paramref name=\"unit\"/>.",
 				"/// Cross-dimension calls (e.g. passing a non-" + dim.Name + " unit) fail at compile time.",
 				Emit.SummaryClose,
 				"/// <param name=\"unit\">The dimensionally-compatible target unit.</param>",
 				"/// <returns>The value expressed in <paramref name=\"unit\"/>.</returns>",
-			],
-			Keywords = [Emit.Public, "T"],
+			},
+			Keywords = {Emit.Public, "T"},
 			Name = "In",
 			Parameters =
-			[
+			{
 				new ParameterTemplate { Type = $"global::ktsu.Semantics.Quantities.I{dim.Name}Unit", Name = "unit" },
-			],
-			BodyFactory = (body) => body.Write(" => unit.FromBase(Value);"),
+			},
+			BodyFactory = (body) => body.Write("=> unit.FromBase(Value);"),
 		});
 	}
 
@@ -833,30 +833,31 @@ private void EmitV0BaseType(
 		{
 			FileName = $"{typeName}.g.cs",
 			Namespace = "ktsu.Semantics.Quantities",
-			Usings = ["System.Numerics"],
+			Usings = {"System.Numerics"},
 		};
 
 		ClassTemplate cls = new()
 		{
 			Comments =
-			[
+			{
 				Emit.SummaryOpen,
 				$"/// Magnitude (Vector0) quantity for the {dim.Name} dimension.",
 				Emit.SummaryClose,
 				"/// <typeparam name=\"T\">The numeric storage type.</typeparam>",
-			],
-			Keywords = [Emit.Public, "partial", "record"],
+			},
+			Kind = TypeKind.Record,
+			Keywords = {Emit.Public, "partial"},
 			Name = fullType,
 			BaseClass = $"PhysicalQuantity<{fullType}, T>",
-			Interfaces = [$"IVector0<{fullType}, T>"],
-			Constraints = ["where T : struct, INumber<T>"],
+			Interfaces = {$"IVector0<{fullType}, T>"},
+			Constraints = {"where T : struct, INumber<T>"},
 		};
 
 		// Zero property (satisfies IVector0)
 		cls.Members.Add(new FieldTemplate()
 		{
-			Comments = ["/// <summary>Gets a quantity with value zero.</summary>"],
-			Keywords = [Emit.Public, Emit.Static, fullType],
+			Comments = {"/// <summary>Gets a quantity with value zero.</summary>"},
+			Keywords = {Emit.Public, Emit.Static, fullType},
 			Name = "Zero => Create(T.Zero)",
 		});
 
@@ -882,21 +883,21 @@ private void EmitV0BaseType(
 		cls.Members.Add(new MethodTemplate()
 		{
 			Comments =
-			[
+			{
 				Emit.SummaryOpen,
 				$"/// Subtracts two {typeName} values, returning the absolute difference as a non-negative {typeName}.",
 				"/// Magnitude subtraction stays a magnitude (per the unified-vector model).",
 				Emit.SummaryClose,
-			],
-			Attributes = [Emit.PhysicsOperatorSuppression],
-			Keywords = [Emit.Public, Emit.Static, fullType],
+			},
+			Attributes = {Emit.PhysicsOperatorSuppression},
+			Keywords = {Emit.Public, Emit.Static, fullType},
 			Name = "operator -",
 			Parameters =
-			[
+			{
 				new ParameterTemplate { Type = fullType, Name = "left" },
 				new ParameterTemplate { Type = fullType, Name = Emit.RightParameter },
-			],
-			BodyFactory = (body) => body.Write(" => Create(T.Abs(left.Quantity - right.Quantity));"),
+			},
+			BodyFactory = (body) => body.Write("=> Create(T.Abs(left.Quantity - right.Quantity));"),
 		});
 
 		// Cross-dimensional operators
@@ -926,30 +927,31 @@ private void EmitV1BaseType(
 		{
 			FileName = $"{typeName}.g.cs",
 			Namespace = "ktsu.Semantics.Quantities",
-			Usings = ["System.Numerics"],
+			Usings = {"System.Numerics"},
 		};
 
 		ClassTemplate cls = new()
 		{
 			Comments =
-			[
+			{
 				Emit.SummaryOpen,
 				$"/// Signed one-dimensional (Vector1) quantity for the {dim.Name} dimension.",
 				Emit.SummaryClose,
 				"/// <typeparam name=\"T\">The numeric storage type.</typeparam>",
-			],
-			Keywords = [Emit.Public, "partial", "record"],
+			},
+			Kind = TypeKind.Record,
+			Keywords = {Emit.Public, "partial"},
 			Name = fullType,
 			BaseClass = $"PhysicalQuantity<{fullType}, T>",
-			Interfaces = [$"IVector1<{fullType}, T>"],
-			Constraints = ["where T : struct, INumber<T>"],
+			Interfaces = {$"IVector1<{fullType}, T>"},
+			Constraints = {"where T : struct, INumber<T>"},
 		};
 
 		// Zero property (satisfies IVector1)
 		cls.Members.Add(new FieldTemplate()
 		{
-			Comments = ["/// <summary>Gets a quantity with value zero.</summary>"],
-			Keywords = [Emit.Public, Emit.Static, fullType],
+			Comments = {"/// <summary>Gets a quantity with value zero.</summary>"},
+			Keywords = {Emit.Public, Emit.Static, fullType},
 			Name = "Zero => Create(T.Zero)",
 		});
 
@@ -972,16 +974,16 @@ private void EmitV1BaseType(
 			cls.Members.Add(new MethodTemplate()
 			{
 				Comments =
-				[
+				{
 					Emit.SummaryOpen,
 					$"/// Gets the magnitude of this quantity as a <see cref=\"{v0TypeName}{{T}}\"/>.",
 					Emit.SummaryClose,
 					$"/// <returns>The non-negative magnitude.</returns>",
-				],
-				Keywords = [Emit.Public, $"{v0TypeName}<T>"],
+				},
+				Keywords = {Emit.Public, $"{v0TypeName}<T>"},
 				Name = "Magnitude",
-				Parameters = [],
-				BodyFactory = (body) => body.Write($" => {v0TypeName}<T>.Create(T.Abs(Value));"),
+				Parameters = {},
+				BodyFactory = (body) => body.Write($"=> {v0TypeName}<T>.Create(T.Abs(Value));"),
 			});
 		}
 
@@ -1107,31 +1109,32 @@ private void EmitOverloadType(
 			{
 				FileName = $"{typeName}.g.cs",
 				Namespace = "ktsu.Semantics.Quantities",
-				Usings = ["System.Numerics"],
+				Usings = {"System.Numerics"},
 			};
 
 			ClassTemplate cls = new()
 			{
 				Comments =
-				[
+				{
 					Emit.SummaryOpen,
 					$"/// {overload.Description}",
 					$"/// Semantic overload of <see cref=\"{baseTypeName}{{T}}\"/>.",
 					Emit.SummaryClose,
 					"/// <typeparam name=\"T\">The numeric storage type.</typeparam>",
-				],
-				Keywords = [Emit.Public, "partial", "record"],
+				},
+				Kind = TypeKind.Record,
+			Keywords = {Emit.Public, "partial"},
 				Name = fullType,
 				BaseClass = $"PhysicalQuantity<{fullType}, T>",
-				Interfaces = [interfaceName],
-				Constraints = ["where T : struct, INumber<T>"],
+				Interfaces = {interfaceName},
+				Constraints = {"where T : struct, INumber<T>"},
 			};
 
 			// Zero property
 			cls.Members.Add(new FieldTemplate()
 			{
-				Comments = ["/// <summary>Gets a quantity with value zero.</summary>"],
-				Keywords = [Emit.Public, Emit.Static, fullType],
+				Comments = {"/// <summary>Gets a quantity with value zero.</summary>"},
+				Keywords = {Emit.Public, Emit.Static, fullType},
 				Name = "Zero => Create(T.Zero)",
 			});
 
@@ -1158,31 +1161,31 @@ private void EmitOverloadType(
 			// Implicit widening to base type
 			cls.Members.Add(new MethodTemplate()
 			{
-				Comments = [$"/// <summary>Implicit conversion to {baseTypeName}.</summary>"],
-				Keywords = [Emit.Public, Emit.Static, "implicit", "operator"],
+				Comments = {$"/// <summary>Implicit conversion to {baseTypeName}.</summary>"},
+				Keywords = {Emit.Public, Emit.Static, "implicit", "operator"},
 				Name = baseFullType,
-				Parameters = [new ParameterTemplate { Type = fullType, Name = Emit.ValueParameter }],
-				BodyFactory = (body) => body.Write($" => {baseFullType}.Create(value.Value);"),
+				Parameters = {new ParameterTemplate { Type = fullType, Name = Emit.ValueParameter }},
+				BodyFactory = (body) => body.Write($"=> {baseFullType}.Create(value.Value);"),
 			});
 
 			// Explicit narrowing from base type
 			cls.Members.Add(new MethodTemplate()
 			{
-				Comments = [$"/// <summary>Explicit conversion from {baseTypeName}.</summary>"],
-				Keywords = [Emit.Public, Emit.Static, "explicit", "operator"],
+				Comments = {$"/// <summary>Explicit conversion from {baseTypeName}.</summary>"},
+				Keywords = {Emit.Public, Emit.Static, "explicit", "operator"},
 				Name = fullType,
-				Parameters = [new ParameterTemplate { Type = baseFullType, Name = Emit.ValueParameter }],
-				BodyFactory = (body) => body.Write($" => Create(value.Value);"),
+				Parameters = {new ParameterTemplate { Type = baseFullType, Name = Emit.ValueParameter }},
+				BodyFactory = (body) => body.Write($"=> Create(value.Value);"),
 			});
 
 			// Factory-style narrowing from base
 			cls.Members.Add(new MethodTemplate()
 			{
-				Comments = [$"/// <summary>Creates a {typeName} from a {baseTypeName} value.</summary>"],
-				Keywords = [Emit.Public, Emit.Static, fullType],
+				Comments = {$"/// <summary>Creates a {typeName} from a {baseTypeName} value.</summary>"},
+				Keywords = {Emit.Public, Emit.Static, fullType},
 				Name = "From",
-				Parameters = [new ParameterTemplate { Type = baseFullType, Name = Emit.ValueParameter }],
-				BodyFactory = (body) => body.Write(" => Create(value.Value);"),
+				Parameters = {new ParameterTemplate { Type = baseFullType, Name = Emit.ValueParameter }},
+				BodyFactory = (body) => body.Write("=> Create(value.Value);"),
 			});
 
 			// V0 overload subtraction returns the same V0 of T.Abs(left - right) (locked
@@ -1193,16 +1196,16 @@ private void EmitOverloadType(
 			{
 				cls.Members.Add(new MethodTemplate()
 				{
-					Comments = [$"/// <summary>Subtracts two {typeName} values, returning the absolute difference as a non-negative {typeName}.</summary>"],
-					Attributes = [Emit.PhysicsOperatorSuppression],
-					Keywords = [Emit.Public, Emit.Static, fullType],
+					Comments = {$"/// <summary>Subtracts two {typeName} values, returning the absolute difference as a non-negative {typeName}.</summary>"},
+					Attributes = {Emit.PhysicsOperatorSuppression},
+					Keywords = {Emit.Public, Emit.Static, fullType},
 					Name = "operator -",
 					Parameters =
-					[
+					{
 						new ParameterTemplate { Type = fullType, Name = "left" },
 						new ParameterTemplate { Type = fullType, Name = Emit.RightParameter },
-					],
-					BodyFactory = (body) => body.Write(" => Create(T.Abs(left.Quantity - right.Quantity));"),
+					},
+					BodyFactory = (body) => body.Write("=> Create(T.Abs(left.Quantity - right.Quantity));"),
 				});
 			}
 
@@ -1220,11 +1223,11 @@ private void EmitOverloadType(
 					string expr = rel.Value; // uses "Value" referring to this instance
 					cls.Members.Add(new MethodTemplate()
 					{
-						Comments = [$"/// <summary>Converts this {typeName} to a {targetName}.</summary>"],
-						Keywords = [Emit.Public, targetType],
+						Comments = {$"/// <summary>Converts this {typeName} to a {targetName}.</summary>"},
+						Keywords = {Emit.Public, targetType},
 						Name = methodName,
-						Parameters = [],
-						BodyFactory = (body) => body.Write($" => {targetType}.Create({expr});"),
+						Parameters = {},
+						BodyFactory = (body) => body.Write($"=> {targetType}.Create({expr});"),
 					});
 				}
 				else if (methodName.StartsWith("From", StringComparison.Ordinal))
@@ -1236,11 +1239,11 @@ private void EmitOverloadType(
 					string expr = rel.Value.Replace("Value", "source.Value");
 					cls.Members.Add(new MethodTemplate()
 					{
-						Comments = [$"/// <summary>Creates a {typeName} from a {sourceName} value.</summary>"],
-						Keywords = [Emit.Public, Emit.Static, fullType],
+						Comments = {$"/// <summary>Creates a {typeName} from a {sourceName} value.</summary>"},
+						Keywords = {Emit.Public, Emit.Static, fullType},
 						Name = methodName,
-						Parameters = [new ParameterTemplate { Type = sourceType, Name = "source" }],
-						BodyFactory = (body) => body.Write($" => Create({expr});"),
+						Parameters = {new ParameterTemplate { Type = sourceType, Name = "source" }},
+						BodyFactory = (body) => body.Write($"=> Create({expr});"),
 					});
 				}
 			}
@@ -1346,20 +1349,20 @@ private static void EmitScalarOperators(
 				cls.Members.Add(new MethodTemplate()
 				{
 					Comments =
-					[
+					{
 						Emit.SummaryOpen,
 						$"/// {(op.Op == "*" ? "Multiplies" : "Divides")} {op.LeftTypeName} by {op.RightTypeName} to produce {op.ReturnTypeName}.",
 						Emit.SummaryClose,
-					],
-					Attributes = [Emit.PhysicsOperatorSuppression],
-					Keywords = [Emit.Public, Emit.Static, $"{op.ReturnTypeName}<T>"],
+					},
+					Attributes = {Emit.PhysicsOperatorSuppression},
+					Keywords = {Emit.Public, Emit.Static, $"{op.ReturnTypeName}<T>"},
 					Name = $"operator {op.Op}",
 					Parameters =
-					[
+					{
 						new ParameterTemplate { Type = $"{op.LeftTypeName}<T>", Name = "left" },
 						new ParameterTemplate { Type = $"{op.RightTypeName}<T>", Name = Emit.RightParameter },
-					],
-					BodyFactory = (body) => body.Write($" => {helperName}<{op.ReturnTypeName}<T>>(left, right);"),
+					},
+					BodyFactory = (body) => body.Write($"=> {helperName}<{op.ReturnTypeName}<T>>(left, right);"),
 				});
 			}
 			else
@@ -1399,7 +1402,7 @@ private static void EmitInlineCrossDimOp(
 		{
 			// VN op V0: component-wise with right.Value
 			string initExpr = string.Join(", ", resultComponents.Select(c => $"{c} = left.{c} {op.Op} right.Value"));
-			bodyExpr = $" => new() {{ {initExpr} }};";
+			bodyExpr = $"=> new() {{ {initExpr} }};";
 		}
 		else if (leftForm <= 1 && rightForm >= 2)
 		{
@@ -1407,7 +1410,7 @@ private static void EmitInlineCrossDimOp(
 			if (op.Op == "*")
 			{
 				string initExpr = string.Join(", ", resultComponents.Select(c => $"{c} = left.Value {op.Op} right.{c}"));
-				bodyExpr = $" => new() {{ {initExpr} }};";
+				bodyExpr = $"=> new() {{ {initExpr} }};";
 			}
 			else
 			{
@@ -1423,19 +1426,19 @@ private static void EmitInlineCrossDimOp(
 		cls.Members.Add(new MethodTemplate()
 		{
 			Comments =
-			[
+			{
 				Emit.SummaryOpen,
 				$"/// {(op.Op == "*" ? "Multiplies" : "Divides")} {op.LeftTypeName} by {op.RightTypeName} to produce {op.ReturnTypeName}.",
 				Emit.SummaryClose,
-			],
-			Attributes = [Emit.PhysicsOperatorSuppression],
-			Keywords = [Emit.Public, Emit.Static, $"{op.ReturnTypeName}<T>"],
+			},
+			Attributes = {Emit.PhysicsOperatorSuppression},
+			Keywords = {Emit.Public, Emit.Static, $"{op.ReturnTypeName}<T>"},
 			Name = $"operator {op.Op}",
 			Parameters =
-			[
+			{
 				new ParameterTemplate { Type = $"{op.LeftTypeName}<T>", Name = "left" },
 				new ParameterTemplate { Type = $"{op.RightTypeName}<T>", Name = Emit.RightParameter },
-			],
+			},
 			BodyFactory = (body) => body.Write(bodyExpr),
 		});
 	}
diff --git a/Semantics.SourceGenerators/Generators/UnitsGenerator.cs b/Semantics.SourceGenerators/Generators/UnitsGenerator.cs
index ffda80db..c34ffb78 100644
--- a/Semantics.SourceGenerators/Generators/UnitsGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/UnitsGenerator.cs
@@ -10,7 +10,8 @@ namespace Semantics.SourceGenerators;
 using Microsoft.CodeAnalysis;
 using Semantics.SourceGenerators.CodeGen;
 using Semantics.SourceGenerators.Models;
-using Semantics.SourceGenerators.Templates;
+using ktsu.CodeBlocker.Templates;
+using TypeKind = ktsu.CodeBlocker.Templates.TypeKind;
 
 /// <summary>
 /// Source generator that creates the per-unit record types and the static <c>Units</c>
@@ -64,10 +65,10 @@ private static void GenerateInner(SourceProductionContext context, UnitsMetadata
 			FileName = "Units.g.cs",
 			Namespace = "ktsu.Semantics.Quantities.Units",
 			Usings =
-			[
+			{
 				"ktsu.Semantics.Quantities",
 				"static ktsu.Semantics.Quantities.Units.ConversionConstants",
-			],
+			},
 		};
 
 		List<string> catalogueUnitNames = [];
@@ -133,63 +134,63 @@ private static ClassTemplate BuildUnitClass(UnitDefinition unit, List<string> di
 			? $"PhysicalDimensions.{dims[0]}"
 			: "null!";
 
-		return new ClassTemplate()
+		return new ClassTemplate
 		{
 			Comments =
-			[
+			{
 				Emit.SummaryOpen,
 				$"/// {unit.Description}",
 				Emit.SummaryClose,
-			],
-			Keywords = [Emit.Public, "sealed", "record"],
+			},
+			Kind = TypeKind.Record,
+			Keywords = {Emit.Public, "sealed"},
 			Name = unit.Name,
-			Interfaces = interfaces,
 			Members =
-			[
+			{
 				new ConstructorTemplate()
 				{
-					Comments = ["/// <summary>Initializes a new instance of the unit.</summary>"],
-					Keywords = [Emit.Public],
+					Comments = {"/// <summary>Initializes a new instance of the unit.</summary>"},
+					Keywords = {Emit.Public},
 					Name = unit.Name,
 				},
 				new FieldTemplate()
 				{
-					Comments = ["/// <summary>Gets the full name of the unit.</summary>"],
-					Keywords = [Emit.Public, "string"],
+					Comments = {"/// <summary>Gets the full name of the unit.</summary>"},
+					Keywords = {Emit.Public, "string"},
 					Name = $"Name => \"{unit.Name}\"",
 				},
 				new FieldTemplate()
 				{
-					Comments = ["/// <summary>Gets the symbol/abbreviation of the unit.</summary>"],
-					Keywords = [Emit.Public, "string"],
+					Comments = {"/// <summary>Gets the symbol/abbreviation of the unit.</summary>"},
+					Keywords = {Emit.Public, "string"},
 					Name = $"Symbol => \"{unit.Symbol}\"",
 				},
 				new FieldTemplate()
 				{
-					Comments = ["/// <summary>Gets the unit system this unit belongs to.</summary>"],
-					Keywords = [Emit.Public, "UnitSystem"],
+					Comments = {"/// <summary>Gets the unit system this unit belongs to.</summary>"},
+					Keywords = {Emit.Public, "UnitSystem"},
 					Name = $"System => UnitSystem.{unit.System}",
 				},
 				new FieldTemplate()
 				{
-					Comments = ["/// <summary>Gets the physical dimension this unit measures.</summary>"],
-					Keywords = [Emit.Public, "DimensionInfo"],
+					Comments = {"/// <summary>Gets the physical dimension this unit measures.</summary>"},
+					Keywords = {Emit.Public, "DimensionInfo"},
 					Name = $"Dimension => {dimensionExpr}",
 				},
 				new FieldTemplate()
 				{
-					Comments = ["/// <summary>Gets the multiplication factor used in the to-base affine conversion.</summary>"],
-					Keywords = [Emit.Public, "double"],
+					Comments = {"/// <summary>Gets the multiplication factor used in the to-base affine conversion.</summary>"},
+					Keywords = {Emit.Public, "double"},
 					Name = $"ToBaseFactor => {factorExpr}",
 				},
 				new FieldTemplate()
 				{
-					Comments = ["/// <summary>Gets the additive offset used in the to-base affine conversion.</summary>"],
-					Keywords = [Emit.Public, "double"],
+					Comments = {"/// <summary>Gets the additive offset used in the to-base affine conversion.</summary>"},
+					Keywords = {Emit.Public, "double"},
 					Name = $"ToBaseOffset => {offsetExpr}",
 				},
-			],
-		};
+			},
+		}.WithInterfaces(interfaces);
 	}
 
 	/// <summary>
@@ -201,13 +202,14 @@ private static ClassTemplate BuildUnitsCatalogue(List<string> catalogueUnitNames
 		ClassTemplate unitsCatalogue = new()
 		{
 			Comments =
-			[
+			{
 				Emit.SummaryOpen,
 				"/// Static catalogue exposing one singleton per declared unit. Generated quantity",
 				"/// types accept these on their typed <c>In(...)</c> methods.",
 				Emit.SummaryClose,
-			],
-			Keywords = [Emit.Public, Emit.Static, "class"],
+			},
+			Kind = TypeKind.Class,
+			Keywords = {Emit.Public, Emit.Static},
 			Name = "Units",
 		};
 
@@ -215,8 +217,8 @@ private static ClassTemplate BuildUnitsCatalogue(List<string> catalogueUnitNames
 		{
 			unitsCatalogue.Members.Add(new FieldTemplate()
 			{
-				Comments = [$"/// <summary>Singleton <c>{unitName}</c> instance.</summary>"],
-				Keywords = [Emit.Public, Emit.Static, "readonly", unitName],
+				Comments = {$"/// <summary>Singleton <c>{unitName}</c> instance.</summary>"},
+				Keywords = {Emit.Public, Emit.Static, "readonly", unitName},
 				Name = unitName,
 				DefaultValue = $"new {unitName}()",
 			});
diff --git a/Semantics.SourceGenerators/SemanticsGenerator.cs b/Semantics.SourceGenerators/SemanticsGenerator.cs
index cd8b80b7..a88e56fc 100644
--- a/Semantics.SourceGenerators/SemanticsGenerator.cs
+++ b/Semantics.SourceGenerators/SemanticsGenerator.cs
@@ -5,7 +5,7 @@ namespace Semantics.SourceGenerators;
 using ktsu.CodeBlocker;
 using Microsoft.CodeAnalysis;
 using Semantics.SourceGenerators.CodeGen;
-using Semantics.SourceGenerators.Templates;
+using ktsu.CodeBlocker.Templates;
 
 /// <summary>
 /// The settings every generator in this repository shares, in one place.
@@ -46,7 +46,7 @@ public abstract class SemanticsGenerator<T>(string metadataFileName) : Generator
 	/// Writes the header every generated file in this repository starts with.
 	/// </summary>
 	/// <param name="codeBlocker">The <see cref="CodeBlocker"/> to write to.</param>
-	private protected static void WriteHeaderTo(CodeBlocker codeBlocker) =>
+	protected static void WriteHeaderTo(CodeBlocker codeBlocker) =>
 		WriteFileHeader(codeBlocker, SemanticsGeneratorSettings.Copyright);
 
 	/// <summary>
@@ -54,7 +54,7 @@ private protected static void WriteHeaderTo(CodeBlocker codeBlocker) =>
 	/// </summary>
 	/// <param name="codeBlocker">The <see cref="CodeBlocker"/> to write to.</param>
 	/// <param name="sourceFileTemplate">The file to write.</param>
-	private protected static void WriteSourceFileTo(CodeBlocker codeBlocker, SourceFileTemplate sourceFileTemplate) =>
+	protected static void WriteSourceFileTo(CodeBlocker codeBlocker, SourceFileTemplate sourceFileTemplate) =>
 		WriteSourceFile(codeBlocker, sourceFileTemplate, SemanticsGeneratorSettings.Copyright);
 }
 
@@ -77,7 +77,7 @@ public abstract class SemanticsMultiFileGenerator : GeneratorBase
 	/// Writes the header every generated file in this repository starts with.
 	/// </summary>
 	/// <param name="codeBlocker">The <see cref="CodeBlocker"/> to write to.</param>
-	private protected static void WriteHeaderTo(CodeBlocker codeBlocker) =>
+	protected static void WriteHeaderTo(CodeBlocker codeBlocker) =>
 		WriteFileHeader(codeBlocker, SemanticsGeneratorSettings.Copyright);
 
 	/// <summary>
@@ -85,6 +85,6 @@ private protected static void WriteHeaderTo(CodeBlocker codeBlocker) =>
 	/// </summary>
 	/// <param name="codeBlocker">The <see cref="CodeBlocker"/> to write to.</param>
 	/// <param name="sourceFileTemplate">The file to write.</param>
-	private protected static void WriteSourceFileTo(CodeBlocker codeBlocker, SourceFileTemplate sourceFileTemplate) =>
+	protected static void WriteSourceFileTo(CodeBlocker codeBlocker, SourceFileTemplate sourceFileTemplate) =>
 		WriteSourceFile(codeBlocker, sourceFileTemplate, SemanticsGeneratorSettings.Copyright);
 }
diff --git a/Semantics.SourceGenerators/TemplateExtensions.cs b/Semantics.SourceGenerators/TemplateExtensions.cs
new file mode 100644
index 00000000..67676164
--- /dev/null
+++ b/Semantics.SourceGenerators/TemplateExtensions.cs
@@ -0,0 +1,52 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace Semantics.SourceGenerators;
+
+using System.Collections.Generic;
+using ktsu.CodeBlocker.Templates;
+
+/// <summary>
+/// Helpers for filling a template's collections from a sequence.
+/// </summary>
+/// <remarks>
+/// The template model exposes its collections as read-only properties, which is the right shape for
+/// a public API — but it means a caller holding a prebuilt list cannot assign it in an object
+/// initializer. These keep those call sites to one expression instead of forcing the template out
+/// into a local and a loop.
+/// </remarks>
+internal static class TemplateExtensions
+{
+	/// <summary>
+	/// Adds every comment in <paramref name="comments"/> to the template.
+	/// </summary>
+	/// <typeparam name="T">The template type.</typeparam>
+	/// <param name="template">The template to add to.</param>
+	/// <param name="comments">The comment lines, each written verbatim.</param>
+	/// <returns>The same template, for chaining.</returns>
+	internal static T WithComments<T>(this T template, IEnumerable<string> comments)
+		where T : TemplateBase
+	{
+		foreach (string comment in comments)
+		{
+			template.Comments.Add(comment);
+		}
+
+		return template;
+	}
+
+	/// <summary>
+	/// Adds every interface in <paramref name="interfaces"/> to the type.
+	/// </summary>
+	/// <param name="template">The type to add to.</param>
+	/// <param name="interfaces">The interface names.</param>
+	/// <returns>The same template, for chaining.</returns>
+	internal static ClassTemplate WithInterfaces(this ClassTemplate template, IEnumerable<string> interfaces)
+	{
+		foreach (string name in interfaces)
+		{
+			template.Interfaces.Add(name);
+		}
+
+		return template;
+	}
+}
diff --git a/Semantics.SourceGenerators/Templates/ClassTemplate.cs b/Semantics.SourceGenerators/Templates/ClassTemplate.cs
deleted file mode 100644
index ccc84557..00000000
--- a/Semantics.SourceGenerators/Templates/ClassTemplate.cs
+++ /dev/null
@@ -1,152 +0,0 @@
-// Copyright (c) 2023-2026 ktsu-dev contributors
-
-namespace Semantics.SourceGenerators.Templates;
-
-using System.Collections.Generic;
-using System.Linq;
-using ktsu.CodeBlocker;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-
-internal class ClassTemplate : TemplateBase
-{
-
-	public string BaseClass { get; set; } = string.Empty;
-	public List<string> Interfaces { get; set; } = [];
-	public List<string> Constraints { get; set; } = [];
-	public List<MemberTemplate> Members { get; set; } = [];
-	public List<ClassTemplate> NestedClasses { get; set; } = [];
-
-	public override void WriteTo(CodeBlocker codeBlocker)
-	{
-		// specify class/struct/ record etc as keywords
-		base.WriteTo(codeBlocker);
-
-		codeBlocker.Write($"{Name}");
-
-		WriteBaseClassAndInterfacesTo(codeBlocker);
-		WriteConstraintsTo(codeBlocker);
-		WriteMembersTo(codeBlocker);
-	}
-
-	private void WriteBaseClassAndInterfacesTo(CodeBlocker codeBlocker)
-	{
-		bool hasBaseClass = !string.IsNullOrEmpty(BaseClass);
-		bool hasInterfaces = Interfaces.Count > 0;
-		bool hasBaseClassOrInterfaces = hasBaseClass || hasInterfaces;
-		if (hasBaseClassOrInterfaces)
-		{
-			codeBlocker.Write($" : ");
-		}
-
-		List<string> baseAndInterfaces = [];
-		if (hasBaseClass)
-		{
-			baseAndInterfaces.Add(BaseClass);
-		}
-
-		baseAndInterfaces.AddRange(Interfaces);
-
-		codeBlocker.Write(string.Join(", ", baseAndInterfaces));
-
-		if (hasBaseClassOrInterfaces)
-		{
-			codeBlocker.NewLine();
-		}
-	}
-
-	public void WriteConstraintsTo(CodeBlocker codeBlocker)
-	{
-		foreach (string constraint in Constraints)
-		{
-			codeBlocker.WriteLine($"\t{constraint}");
-		}
-	}
-
-	public void WriteMembersTo(CodeBlocker codeBlocker)
-	{
-		if (Members.Count == 0 && NestedClasses.Count == 0)
-		{
-			codeBlocker.WriteLine("{ }");
-			return;
-		}
-
-		IEnumerable<MemberTemplate> sortedMembers = Members.OrderBy(MemberTemplate.MemberSortOrder);
-
-		using (new ScopeWithTrailingSemicolon(codeBlocker))
-		{
-			foreach (MemberTemplate member in sortedMembers)
-			{
-				member.WriteTo(codeBlocker);
-				codeBlocker.NewLine();
-			}
-
-			foreach (ClassTemplate nestedClass in NestedClasses)
-			{
-				codeBlocker.NewLine();
-				nestedClass.WriteTo(codeBlocker);
-			}
-		}
-	}
-}
-
-internal static class ClassTemplateExtensions
-{
-	public static CodeBlocker AddClass(this CodeBlocker codeBlocker, ClassTemplate classTemplate)
-	{
-		classTemplate.WriteTo(codeBlocker);
-
-		return codeBlocker;
-	}
-
-	public static CodeBlocker AddClassName(this CodeBlocker codeBlocker, ClassTemplate classTemplate)
-	{
-		codeBlocker.Write(classTemplate.Name);
-		return codeBlocker;
-	}
-
-	public static CodeBlocker AddInheritance(this CodeBlocker codeBlocker, ClassTemplate classTemplate)
-	{
-		bool hasBaseClass = !string.IsNullOrEmpty(classTemplate.BaseClass);
-		bool hasInterfaces = classTemplate.Interfaces.Count > 0;
-		bool hasBaseClassOrInterfaces = hasBaseClass || hasInterfaces;
-
-		if (hasBaseClassOrInterfaces)
-		{
-			codeBlocker.Write($" : ");
-		}
-
-		List<string> baseAndInterfaces = [];
-		if (hasBaseClass)
-		{
-			baseAndInterfaces.Add(classTemplate.BaseClass);
-		}
-
-		baseAndInterfaces.AddRange(classTemplate.Interfaces);
-
-		codeBlocker.Write(string.Join(", ", baseAndInterfaces));
-
-		if (hasBaseClassOrInterfaces)
-		{
-			codeBlocker.NewLine();
-		}
-
-		if (string.IsNullOrEmpty(classTemplate.BaseClass) && classTemplate.Interfaces.Count == 0)
-		{
-			return codeBlocker;
-		}
-		codeBlocker.Write(" : ");
-		if (!string.IsNullOrEmpty(classTemplate.BaseClass))
-		{
-			codeBlocker.Write(classTemplate.BaseClass);
-		}
-		if (classTemplate.Interfaces.Count > 0)
-		{
-			if (!string.IsNullOrEmpty(classTemplate.BaseClass))
-			{
-				codeBlocker.Write(", ");
-			}
-			codeBlocker.Write(string.Join(", ", classTemplate.Interfaces));
-		}
-		return codeBlocker;
-	}
-}
diff --git a/Semantics.SourceGenerators/Templates/ConstructorTemplate.cs b/Semantics.SourceGenerators/Templates/ConstructorTemplate.cs
deleted file mode 100644
index c663d12f..00000000
--- a/Semantics.SourceGenerators/Templates/ConstructorTemplate.cs
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright (c) 2023-2026 ktsu-dev contributors
-
-namespace Semantics.SourceGenerators.Templates;
-
-using System;
-using System.Collections.Generic;
-using ktsu.CodeBlocker;
-
-internal class ConstructorTemplate : MemberTemplate
-{
-	public List<ParameterTemplate> Parameters { get; set; } = [];
-	public List<string> BaseParameters { get; set; } = [];
-	public Action<CodeBlocker>? BodyFactory { get; set; } = (sw) => { };
-	public override void WriteTo(CodeBlocker codeBlocker)
-	{
-		base.WriteTo(codeBlocker);
-		WriteParametersTo(codeBlocker);
-		WriteBaseParametersTo(codeBlocker);
-		WriteBodyTo(codeBlocker);
-	}
-
-	private void WriteParametersTo(CodeBlocker codeBlocker)
-	{
-		List<string> parameterStrings = [];
-		foreach (ParameterTemplate parameterTemplate in Parameters)
-		{
-			CodeBlocker parameterStringWriter = CodeBlocker.Create();
-			parameterTemplate.WriteTo(parameterStringWriter);
-			parameterStrings.Add(parameterStringWriter.ToString());
-		}
-
-		codeBlocker.Write("(");
-		codeBlocker.Write(string.Join(", ", parameterStrings));
-		codeBlocker.Write(")");
-	}
-
-	private void WriteBaseParametersTo(CodeBlocker codeBlocker)
-	{
-		if (BaseParameters.Count == 0)
-		{
-			return; // No base parameters to write
-		}
-
-		codeBlocker.NewLine();
-		codeBlocker.Write(": base");
-		codeBlocker.Write("(");
-		codeBlocker.Write(string.Join(", ", BaseParameters));
-		codeBlocker.Write(")");
-	}
-
-	private void WriteBodyTo(CodeBlocker codeBlocker)
-	{
-		// If there is no body, we just append a semicolon. Abstract methods for example.
-		if (BodyFactory is null)
-		{
-			codeBlocker.Write(";");
-			return;
-		}
-
-		CodeBlocker bodyStringWriter = CodeBlocker.Create();
-		BodyFactory(bodyStringWriter);
-		string bodyString = bodyStringWriter.ToString();
-		string[] bodyLines = bodyString.Split([Environment.NewLine], StringSplitOptions.None);
-		int bodyLineCount = bodyLines.Length;
-
-		// If the body is empty, we just append an empty block. Virtual base methods for example.
-		if (bodyString.Length == 0)
-		{
-			codeBlocker.WriteLine(" { }");
-			return;
-		}
-
-		if (bodyLineCount > 1)
-		{
-			// If the body has multiple lines, we need to write a new line before the opening brace.
-			codeBlocker.NewLine();
-		}
-
-		// BodyFactory should provide the braces, or the expression body
-		codeBlocker.Write(bodyString);
-	}
-}
diff --git a/Semantics.SourceGenerators/Templates/FieldTemplate.cs b/Semantics.SourceGenerators/Templates/FieldTemplate.cs
deleted file mode 100644
index 0aa9048a..00000000
--- a/Semantics.SourceGenerators/Templates/FieldTemplate.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2023-2026 ktsu-dev contributors
-
-namespace Semantics.SourceGenerators.Templates;
-
-using ktsu.CodeBlocker;
-
-internal class FieldTemplate : MemberTemplate
-{
-	public override void WriteTo(CodeBlocker codeBlocker)
-	{
-		base.WriteTo(codeBlocker);
-
-		if (!string.IsNullOrEmpty(DefaultValue))
-		{
-			codeBlocker.Write(" = ");
-			if (DefaultValueIsQuoted)
-			{
-				codeBlocker.Write($"\"{DefaultValue}\"");
-			}
-			else
-			{
-				codeBlocker.Write(DefaultValue);
-			}
-		}
-		codeBlocker.WriteLine(";");
-	}
-}
diff --git a/Semantics.SourceGenerators/Templates/MemberTemplate.cs b/Semantics.SourceGenerators/Templates/MemberTemplate.cs
deleted file mode 100644
index 980100e5..00000000
--- a/Semantics.SourceGenerators/Templates/MemberTemplate.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (c) 2023-2026 ktsu-dev contributors
-
-namespace Semantics.SourceGenerators.Templates;
-
-using ktsu.CodeBlocker;
-
-internal abstract class MemberTemplate : TemplateBase
-{
-	public override void WriteTo(CodeBlocker codeBlocker)
-	{
-		base.WriteTo(codeBlocker);
-		string typeAndName = $"{Type} {Name}".Trim();
-		codeBlocker.Write(typeAndName);
-	}
-
-	internal static int MemberSortOrder(MemberTemplate memberTemplate)
-	{
-		return memberTemplate switch
-		{
-			FieldTemplate => 0,
-			PropertyTemplate => 1,
-			MethodTemplate => 2,
-			_ => 3
-		};
-	}
-}
diff --git a/Semantics.SourceGenerators/Templates/MethodTemplate.cs b/Semantics.SourceGenerators/Templates/MethodTemplate.cs
deleted file mode 100644
index 7be0b5cf..00000000
--- a/Semantics.SourceGenerators/Templates/MethodTemplate.cs
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright (c) 2023-2026 ktsu-dev contributors
-
-namespace Semantics.SourceGenerators.Templates;
-
-using System;
-using System.Collections.Generic;
-using ktsu.CodeBlocker;
-
-internal class MethodTemplate : MemberTemplate
-{
-	public List<ParameterTemplate> Parameters { get; set; } = [];
-	public Action<CodeBlocker>? BodyFactory { get; set; }
-	public override void WriteTo(CodeBlocker codeBlocker)
-	{
-		base.WriteTo(codeBlocker);
-		WriteParametersTo(codeBlocker);
-		WriteBodyTo(codeBlocker);
-	}
-
-	private void WriteParametersTo(CodeBlocker codeBlocker)
-	{
-		List<string> parameterStrings = [];
-		foreach (ParameterTemplate parameterTemplate in Parameters)
-		{
-			CodeBlocker parameterStringWriter = CodeBlocker.Create();
-			parameterTemplate.WriteTo(parameterStringWriter);
-			parameterStrings.Add(parameterStringWriter.ToString());
-		}
-
-		codeBlocker.Write("(");
-		codeBlocker.Write(string.Join(", ", parameterStrings));
-		codeBlocker.Write(")");
-	}
-
-	private void WriteBodyTo(CodeBlocker codeBlocker)
-	{
-		// If there is no body, we just append a semicolon. Abstract methods for example.
-		if (BodyFactory is null)
-		{
-			codeBlocker.Write(";");
-			return;
-		}
-
-		CodeBlocker bodyStringWriter = CodeBlocker.Create();
-		BodyFactory(bodyStringWriter);
-		string bodyString = bodyStringWriter.ToString();
-		string[] bodyLines = bodyString.Split([Environment.NewLine], StringSplitOptions.None);
-		int bodyLineCount = bodyLines.Length;
-
-		// If the body is empty, we just append an empty block. Virtual base methods for example.
-		if (bodyLineCount == 0)
-		{
-			codeBlocker.WriteLine(" { }");
-			return;
-		}
-
-		if (bodyLineCount > 1)
-		{
-			// If the body has multiple lines, we need to write a new line before the opening brace.
-			codeBlocker.NewLine();
-		}
-
-		// BodyFactory should provide the braces, or the expression body
-		codeBlocker.Write(bodyString);
-	}
-}
diff --git a/Semantics.SourceGenerators/Templates/ParameterTemplate.cs b/Semantics.SourceGenerators/Templates/ParameterTemplate.cs
deleted file mode 100644
index 71139c8b..00000000
--- a/Semantics.SourceGenerators/Templates/ParameterTemplate.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2023-2026 ktsu-dev contributors
-
-namespace Semantics.SourceGenerators.Templates;
-
-using ktsu.CodeBlocker;
-
-internal class ParameterTemplate : TemplateBase
-{
-	public override void WriteTo(CodeBlocker codeBlocker)
-	{
-		base.WriteTo(codeBlocker);
-
-		codeBlocker.Write($"{Type} {Name}");
-		if (!string.IsNullOrEmpty(DefaultValue))
-		{
-			codeBlocker.Write($" = ");
-			if (DefaultValueIsQuoted)
-			{
-				codeBlocker.Write($"\"{DefaultValue}\"");
-			}
-			else
-			{
-				codeBlocker.Write(DefaultValue);
-			}
-		}
-	}
-}
diff --git a/Semantics.SourceGenerators/Templates/PropertyTemplate.cs b/Semantics.SourceGenerators/Templates/PropertyTemplate.cs
deleted file mode 100644
index 86c060a9..00000000
--- a/Semantics.SourceGenerators/Templates/PropertyTemplate.cs
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright (c) 2023-2026 ktsu-dev contributors
-
-namespace Semantics.SourceGenerators.Templates;
-
-using System;
-using ktsu.CodeBlocker;
-
-internal class PropertyTemplate : MemberTemplate
-{
-	// Compared by reference in WriteTo to detect auto-property shorthand, so these must stay
-	// single fixed instances; readonly enforces that without changing the comparison.
-	public static readonly Action<CodeBlocker> AutoGet = (sw) => sw.Write("get;");
-	public static readonly Action<CodeBlocker> AutoSet = (sw) => sw.Write("set;");
-	public static readonly Action<CodeBlocker> AutoInit = (sw) => sw.Write("init;");
-
-	public Action<CodeBlocker>? GetterFactory { get; set; }
-	public Action<CodeBlocker>? SetterFactory { get; set; }
-	public string? SetterBody { get; set; }
-	public override void WriteTo(CodeBlocker codeBlocker)
-	{
-		base.WriteTo(codeBlocker);
-
-		if (GetterFactory is null && SetterFactory is null)
-		{
-			// If both are null, we assume it's an abstract property and terminate with a semicolon.
-			codeBlocker.WriteLine(";");
-			return;
-		}
-
-		if (CanUseShorthand)
-		{
-			WriteShorthand(codeBlocker);
-			return;
-		}
-
-		WriteFullAccessors(codeBlocker);
-	}
-
-	/// <summary>
-	/// Gets a value indicating whether both accessors are auto (or absent), in which case the
-	/// whole property fits on one line as <c>{ get; set; }</c>.
-	/// </summary>
-	private bool CanUseShorthand =>
-		(GetterFactory == AutoGet || GetterFactory is null)
-		&& (SetterFactory is null || SetterFactory == AutoSet || SetterFactory == AutoInit);
-
-	private void WriteShorthand(CodeBlocker codeBlocker)
-	{
-		codeBlocker.Write(" { ");
-		GetterFactory?.Invoke(codeBlocker);
-		if (GetterFactory is not null && SetterFactory is not null)
-		{
-			codeBlocker.Write(" ");
-		}
-
-		SetterFactory?.Invoke(codeBlocker);
-		codeBlocker.WriteLine(" }");
-	}
-
-	/// <summary>
-	/// Writes a braced accessor list. Used when either accessor has a custom body.
-	/// </summary>
-	private void WriteFullAccessors(CodeBlocker codeBlocker)
-	{
-		codeBlocker.NewLine();
-		codeBlocker.WriteLine("{");
-		codeBlocker.NewLine();
-
-		WriteAccessor(codeBlocker, GetterFactory, GetterFactory == AutoGet);
-		WriteAccessor(codeBlocker, SetterFactory, SetterFactory == AutoSet || SetterFactory == AutoInit);
-
-		codeBlocker.WriteLine("}");
-	}
-
-	private static void WriteAccessor(CodeBlocker codeBlocker, Action<CodeBlocker>? factory, bool isAuto)
-	{
-		if (factory is null)
-		{
-			return;
-		}
-
-		factory(codeBlocker);
-		if (isAuto)
-		{
-			// An auto accessor writes only "get;"/"set;", so it needs its own line break.
-			codeBlocker.NewLine();
-		}
-	}
-}
diff --git a/Semantics.SourceGenerators/Templates/SourceFileTemplate.cs b/Semantics.SourceGenerators/Templates/SourceFileTemplate.cs
deleted file mode 100644
index b5eddd59..00000000
--- a/Semantics.SourceGenerators/Templates/SourceFileTemplate.cs
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright (c) 2023-2026 ktsu-dev contributors
-
-namespace Semantics.SourceGenerators.Templates;
-using System.Collections.Generic;
-using System.Linq;
-using ktsu.CodeBlocker;
-
-internal class SourceFileTemplate : TemplateBase
-{
-	public string FileName { get; set; } = string.Empty;
-	public string Namespace { get; set; } = string.Empty;
-	public List<string> Usings { get; set; } = [];
-	public List<ClassTemplate> Classes { get; set; } = [];
-}
-
-internal static class SourceFileTemplateExtensions
-{
-	public static CodeBlocker AddSourceFile(this CodeBlocker codeBlocker, SourceFileTemplate template)
-	{
-		codeBlocker.AddTemplate(template);
-		codeBlocker.AddNamespace(template.Namespace);
-		codeBlocker.AddUsings(template.Usings);
-		codeBlocker.AddClasses(template.Classes);
-		return codeBlocker;
-	}
-
-	public static CodeBlocker AddNamespace(this CodeBlocker codeBlocker, string namespaceName)
-	{
-		if (!string.IsNullOrEmpty(namespaceName))
-		{
-			codeBlocker.WriteLine($"namespace {namespaceName};");
-			codeBlocker.NewLine();
-		}
-
-		return codeBlocker;
-	}
-
-	public static CodeBlocker AddUsings(this CodeBlocker codeBlocker, IEnumerable<string> usings)
-	{
-		foreach (string usingDirective in usings)
-		{
-			codeBlocker.WriteLine($"using {usingDirective};");
-		}
-
-		if (usings.Any())
-		{
-			codeBlocker.NewLine();
-		}
-
-		return codeBlocker;
-	}
-
-	public static CodeBlocker AddClasses(this CodeBlocker codeBlocker, IEnumerable<ClassTemplate> classes)
-	{
-		foreach (ClassTemplate classTemplate in classes)
-		{
-			codeBlocker.AddClass(classTemplate);
-			codeBlocker.NewLine();
-		}
-
-		return codeBlocker;
-	}
-}
diff --git a/Semantics.SourceGenerators/Templates/TemplateBase.cs b/Semantics.SourceGenerators/Templates/TemplateBase.cs
deleted file mode 100644
index f78ae673..00000000
--- a/Semantics.SourceGenerators/Templates/TemplateBase.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright (c) 2023-2026 ktsu-dev contributors
-
-namespace Semantics.SourceGenerators.Templates;
-using System.Collections.Generic;
-using System.Linq;
-using ktsu.CodeBlocker;
-
-internal abstract class TemplateBase
-{
-	public string Name { get; set; } = string.Empty;
-	public string Type { get; set; } = string.Empty;
-	public string DefaultValue { get; set; } = string.Empty;
-	public bool DefaultValueIsQuoted { get; set; } = false;
-	public List<string> Attributes { get; set; } = [];
-	public List<string> Keywords { get; set; } = [];
-	public List<string> Comments { get; set; } = [];
-
-	public virtual void WriteTo(CodeBlocker codeBlocker)
-	{
-		codeBlocker.AddComments(Comments);
-		codeBlocker.AddAttributes(Attributes);
-		codeBlocker.AddKeywords(Keywords);
-	}
-}
-
-internal static class TemplateBaseExtensions
-{
-	public static CodeBlocker AddTemplate(this CodeBlocker codeBlocker, TemplateBase template)
-	{
-		codeBlocker.AddComments(template.Comments);
-		codeBlocker.AddAttributes(template.Attributes);
-		codeBlocker.AddKeywords(template.Keywords);
-		return codeBlocker;
-	}
-
-	public static CodeBlocker AddComments(this CodeBlocker codeBlocker, IEnumerable<string> comments)
-	{
-		foreach (string comment in comments)
-		{
-			codeBlocker.WriteLine(comment);
-		}
-		return codeBlocker;
-	}
-
-	public static CodeBlocker AddAttributes(this CodeBlocker codeBlocker, IEnumerable<string> attributes)
-	{
-		foreach (string attribute in attributes)
-		{
-			codeBlocker.Write($"[{attribute}] ");
-		}
-		return codeBlocker;
-	}
-
-	public static CodeBlocker AddKeywords(this CodeBlocker codeBlocker, IEnumerable<string> keywords)
-	{
-		if (keywords.Any())
-		{
-			codeBlocker.Write(string.Join(" ", keywords) + " ");
-		}
-		return codeBlocker;
-	}
-}
diff --git a/Semantics.Test/Quantities/PropertyTemplateTests.cs b/Semantics.Test/Quantities/PropertyTemplateTests.cs
deleted file mode 100644
index 70f228b6..00000000
--- a/Semantics.Test/Quantities/PropertyTemplateTests.cs
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright (c) 2023-2026 ktsu-dev contributors
-
-namespace ktsu.Semantics.Test.Quantities;
-
-using ktsu.CodeBlocker;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using global::Semantics.SourceGenerators.Templates;
-
-/// <summary>
-/// Covers <see cref="PropertyTemplate"/>'s auto-property shorthand emission.
-/// </summary>
-/// <remarks>
-/// <see cref="PropertyTemplate.AutoGet"/>, <see cref="PropertyTemplate.AutoSet"/> and
-/// <see cref="PropertyTemplate.AutoInit"/> are the accessor factories the template compares against
-/// by reference to decide whether a property can be written in shorthand. No generator assigns them
-/// today, so the shorthand branches are currently unreachable from production code — these tests pin
-/// the intended behaviour so the affordance is exercised rather than silently rotting.
-/// </remarks>
-[TestClass]
-public class PropertyTemplateTests
-{
-	[TestMethod]
-	public void WriteTo_AutoGetAndAutoSet_EmitsShorthand()
-	{
-		string output = Emit(new PropertyTemplate
-		{
-			Type = "int",
-			Name = "Count",
-			GetterFactory = PropertyTemplate.AutoGet,
-			SetterFactory = PropertyTemplate.AutoSet,
-		});
-
-		Assert.Contains("int Count { get; set; }", output);
-	}
-
-	[TestMethod]
-	public void WriteTo_AutoGetAndAutoInit_EmitsInitShorthand()
-	{
-		string output = Emit(new PropertyTemplate
-		{
-			Type = "string",
-			Name = "Symbol",
-			GetterFactory = PropertyTemplate.AutoGet,
-			SetterFactory = PropertyTemplate.AutoInit,
-		});
-
-		Assert.Contains("string Symbol { get; init; }", output);
-	}
-
-	[TestMethod]
-	public void WriteTo_NoAccessors_EmitsAbstractProperty()
-	{
-		string output = Emit(new PropertyTemplate
-		{
-			Type = "double",
-			Name = "Value",
-		});
-
-		Assert.Contains("double Value;", output);
-	}
-
-	[TestMethod]
-	public void WriteTo_CustomGetter_EmitsFullBody()
-	{
-		string output = Emit(new PropertyTemplate
-		{
-			Type = "int",
-			Name = "Doubled",
-			GetterFactory = (cb) => cb.Write("get => field * 2;"),
-		});
-
-		Assert.Contains("get => field * 2;", output);
-		Assert.DoesNotContain("{ get;", output, "A custom getter must not be written as auto-property shorthand.");
-	}
-
-	private static string Emit(PropertyTemplate template)
-	{
-		using CodeBlocker codeBlocker = CodeBlocker.Create();
-		template.WriteTo(codeBlocker);
-		return codeBlocker.ToString();
-	}
-}
diff --git a/docs/physics-generator.md b/docs/physics-generator.md
index e5e0103e..43f8daa6 100644
--- a/docs/physics-generator.md
+++ b/docs/physics-generator.md
@@ -19,6 +19,8 @@ For the *why* (the unified vector model), see `docs/strategy-unified-vector-quan
 
 Outputs land under `Semantics.Quantities/Generated/Semantics.SourceGenerators/<GeneratorName>/`. Generated files are **committed** so that the project compiles without first running the generator.
 
+The C# itself is described with the template object model from `ktsu.CodeBlocker.Templates` rather than assembled from `WriteLine` calls. The model owns the punctuation, spacing and indentation: a `BodyFactory` writes only the body (`=> Create(value);`, or a braced block) and the model supplies the separator, the line breaks between members, and the surrounding indent.
+
 ## `dimensions.json` schema
 
 `Semantics.SourceGenerators/Metadata/dimensions.json` is a single object with one key, `physicalDimensions`, whose value is a list of dimension entries. Each entry looks like:

From 55f4f4b4bda1499492b66b9d9d0a47719429436c Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 27 Aug 2026 04:51:58 +0000
Subject: [PATCH 2/2] refactor: pin the generated line terminator, drop the
 rewrite pass [minor]

GeneratedSource existed only to rewrite every line ending after the fact,
because IndentedTextWriter uses Environment.NewLine and committed generator
output has to be byte-identical wherever it was produced. ktsu.CodeBlocker 1.3.0
lets the terminator be pinned at construction, so the rewrite is unnecessary and
the type is gone; GeneratedSource.Add was a normalization wrapper, so call sites
use context.AddSource directly.

It is pinned to LF, not CRLF. The pass being removed rewrote everything to CRLF
on the grounds - stated in its own comment - that .editorconfig said
end_of_line = crlf and .gitattributes said *.cs text eol=crlf. Neither is true
any more: the LF migration in #157 changed them to end_of_line = lf and
* text=auto eol=lf, and nothing updated the generator. Git had been quietly
normalising the difference on every commit ever since - the stored blobs are LF
while every working tree carried CRLF, which is where the permanent "CRLF will
be replaced by LF" warnings came from.

So the generated files are byte-identical as stored (a plain git diff over
Generated/ is empty), and now the working tree matches the repository instead of
disagreeing with it.

That also removes the reason verify-generated ran on windows-latest, which its
comment gave as matching git's autocrlf to the committed CRLF. It runs on
ubuntu-latest now; the alias-props step uses pwsh, which Linux runners have.

Test suite unchanged: 1015 passed, 92 failed - the same Windows-path tests that
fail on main under Linux.

Closes #184

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015sagQjzFv3cnFNM3G271TJ
---
 .github/workflows/verify-generated.yml        |  8 ++--
 CLAUDE.md                                     |  2 +-
 .../CodeGen/GeneratedSource.cs                | 45 -------------------
 .../CodeGen/GeneratorBase.cs                  | 16 ++++++-
 .../Generators/ConversionsGenerator.cs        |  2 +-
 .../Generators/DimensionsGenerator.cs         |  2 +-
 .../Generators/LogarithmicScalesGenerator.cs  |  4 +-
 .../Generators/MagnitudesGenerator.cs         |  2 +-
 .../Generators/PhysicalConstantsGenerator.cs  |  2 +-
 .../Generators/PrecisionGenerator.cs          |  2 +-
 .../Generators/QuantitiesGenerator.cs         | 20 ++++-----
 .../Generators/UnitsGenerator.cs              |  2 +-
 12 files changed, 39 insertions(+), 68 deletions(-)
 delete mode 100644 Semantics.SourceGenerators/CodeGen/GeneratedSource.cs

diff --git a/.github/workflows/verify-generated.yml b/.github/workflows/verify-generated.yml
index cbb411b0..1aa4ffd5 100644
--- a/.github/workflows/verify-generated.yml
+++ b/.github/workflows/verify-generated.yml
@@ -26,9 +26,11 @@ concurrency:
 jobs:
   verify-generated:
     name: Generated files up to date
-    # windows-latest so git's autocrlf matches the committed CRLF line endings and the
-    # diff doesn't flag end-of-line differences.
-    runs-on: windows-latest
+    # Runs on Linux: the generators pin their line terminator to LF, matching
+    # `* text=auto eol=lf` in .gitattributes, so the diff no longer depends on the runner's
+    # autocrlf. (This was windows-latest while the generators emitted CRLF and git normalised
+    # the difference away on commit.)
+    runs-on: ubuntu-latest
     timeout-minutes: 15
     steps:
       - name: Checkout
diff --git a/CLAUDE.md b/CLAUDE.md
index 2dae46c7..2ac9e38d 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -122,7 +122,7 @@ All values are stored in SI base units, so operators read `.Value` directly. Sup
 // Copyright (c) 2023-2026 ktsu-dev contributors
 ```
 
-The text comes from `COPYRIGHT.md`; ktsu.Sdk syncs `.editorconfig`'s `file_header_template` from that file on every build, and `IDE0073` enforces it. If `COPYRIGHT.md` changes, update `GeneratorBase.WriteHeaderTo` to match — generator output is committed source, so a drift there shows up as a diff rather than a build error (`.g.cs` is exempt from `IDE0073`). `SourceGeneratorTests` asserts the emitted header, so the drift fails a test instead.
+The text comes from `COPYRIGHT.md`; ktsu.Sdk syncs `.editorconfig`'s `file_header_template` from that file on every build, and `IDE0073` enforces it. Generated files are written with LF line endings, pinned in `CreateCodeBlocker` to match `* text=auto eol=lf` in `.gitattributes`. If `COPYRIGHT.md` changes, update `GeneratorBase.WriteHeaderTo` to match — generator output is committed source, so a drift there shows up as a diff rather than a build error (`.g.cs` is exempt from `IDE0073`). `SourceGeneratorTests` asserts the emitted header, so the drift fails a test instead.
 
 Generator-emitted files additionally carry `// <auto-generated />`.
 
diff --git a/Semantics.SourceGenerators/CodeGen/GeneratedSource.cs b/Semantics.SourceGenerators/CodeGen/GeneratedSource.cs
deleted file mode 100644
index e09bef63..00000000
--- a/Semantics.SourceGenerators/CodeGen/GeneratedSource.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2023-2026 ktsu-dev contributors
-
-namespace Semantics.SourceGenerators.CodeGen;
-
-using System;
-using Microsoft.CodeAnalysis;
-
-/// <summary>
-/// Helpers for emitting generated sources with host-independent content.
-/// </summary>
-internal static class GeneratedSource
-{
-	/// <summary>
-	/// The line ending emitted for all generated sources.
-	/// </summary>
-	/// <remarks>
-	/// CRLF matches <c>end_of_line = crlf</c> in <c>.editorconfig</c> and <c>*.cs text eol=crlf</c> in
-	/// <c>.gitattributes</c>.
-	/// </remarks>
-	private const string LineEnding = "\r\n";
-
-	/// <summary>
-	/// Adds a generated source file, normalizing its line endings so the output does not depend on the
-	/// operating system the generator runs on.
-	/// </summary>
-	/// <param name="context">The source production context to add the source to.</param>
-	/// <param name="hintName">The name of the generated file.</param>
-	/// <param name="source">The generated source text.</param>
-	/// <remarks>
-	/// <c>ktsu.CodeBlocker</c> writes through <see cref="System.CodeDom.Compiler.IndentedTextWriter"/>, which
-	/// uses <see cref="Environment.NewLine"/> — so the same metadata produced CRLF output on Windows and LF
-	/// output on Linux. Generator output under <c>Semantics.Quantities/Generated/</c> is committed to the
-	/// repository and verified by CI, so it has to be byte-identical regardless of who builds it.
-	/// </remarks>
-	internal static void Add(SourceProductionContext context, string hintName, string source) =>
-		context.AddSource(hintName, NormalizeLineEndings(source));
-
-	/// <summary>
-	/// Rewrites every line ending in the given text to <see cref="LineEnding"/>.
-	/// </summary>
-	/// <param name="source">The text to normalize.</param>
-	/// <returns>The text with normalized line endings.</returns>
-	internal static string NormalizeLineEndings(string source) =>
-		source.Replace(LineEnding, "\n").Replace("\n", LineEnding);
-}
diff --git a/Semantics.SourceGenerators/CodeGen/GeneratorBase.cs b/Semantics.SourceGenerators/CodeGen/GeneratorBase.cs
index 8f28dbb5..d94a1d63 100644
--- a/Semantics.SourceGenerators/CodeGen/GeneratorBase.cs
+++ b/Semantics.SourceGenerators/CodeGen/GeneratorBase.cs
@@ -88,7 +88,21 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
 	/// Creates a <see cref="CodeBlocker"/> configured the way generated sources are written.
 	/// </summary>
 	/// <returns>A new <see cref="CodeBlocker"/>.</returns>
-	protected static CodeBlocker CreateCodeBlocker() => CodeBlocker.Create();
+	/// <remarks>
+	/// The line terminator is pinned rather than inherited from the host. Generated output is
+	/// committed and verified by CI, so it has to be byte-identical wherever it was produced —
+	/// which previously meant rewriting every line ending after the fact, because
+	/// <see cref="System.CodeDom.Compiler.IndentedTextWriter"/> uses
+	/// <see cref="System.Environment.NewLine"/>.
+	/// <para>
+	/// LF, matching <c>* text=auto eol=lf</c> in <c>.gitattributes</c> and
+	/// <c>end_of_line = lf</c> in <c>.editorconfig</c>. The pass this replaces rewrote everything
+	/// to CRLF on the grounds that those files asked for CRLF, which stopped being true at the LF
+	/// migration; git had been quietly normalising the difference away on every commit ever since.
+	/// </para>
+	/// </remarks>
+	protected static CodeBlocker CreateCodeBlocker() =>
+		CodeBlocker.Create(CodeBlocker.DefaultIndentString, NewLines.Lf);
 
 	/// <summary>
 	/// Writes the header every generated file starts with.
diff --git a/Semantics.SourceGenerators/Generators/ConversionsGenerator.cs b/Semantics.SourceGenerators/Generators/ConversionsGenerator.cs
index 7568fbcf..e8f7825a 100644
--- a/Semantics.SourceGenerators/Generators/ConversionsGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/ConversionsGenerator.cs
@@ -74,6 +74,6 @@ protected override void Generate(SourceProductionContext context, ConversionsMet
 
 		WriteSourceFileTo(codeBlocker, sourceFileTemplate);
 
-		GeneratedSource.Add(context, sourceFileTemplate.FileName, codeBlocker.ToString());
+		context.AddSource(sourceFileTemplate.FileName, codeBlocker.ToString());
 	}
 }
diff --git a/Semantics.SourceGenerators/Generators/DimensionsGenerator.cs b/Semantics.SourceGenerators/Generators/DimensionsGenerator.cs
index 91649eb7..252fe598 100644
--- a/Semantics.SourceGenerators/Generators/DimensionsGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/DimensionsGenerator.cs
@@ -146,6 +146,6 @@ protected override void Generate(SourceProductionContext context, DimensionsMeta
 		}
 
 		WriteSourceFileTo(codeBlocker, sourceFileTemplate);
-		GeneratedSource.Add(context, sourceFileTemplate.FileName, codeBlocker.ToString());
+		context.AddSource(sourceFileTemplate.FileName, codeBlocker.ToString());
 	}
 }
diff --git a/Semantics.SourceGenerators/Generators/LogarithmicScalesGenerator.cs b/Semantics.SourceGenerators/Generators/LogarithmicScalesGenerator.cs
index 0d383063..13a75a0c 100644
--- a/Semantics.SourceGenerators/Generators/LogarithmicScalesGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/LogarithmicScalesGenerator.cs
@@ -54,7 +54,7 @@ private static void Report(SourceProductionContext context, string message) =>
 
 	private static void EmitScale(SourceProductionContext context, LogarithmicScaleDefinition scale)
 	{
-		using CodeBlocker cb = CodeBlocker.Create();
+		using CodeBlocker cb = CreateCodeBlocker();
 		string name = scale.Name;
 		string fullType = $"{name}<T>";
 
@@ -108,7 +108,7 @@ private static void EmitScale(SourceProductionContext context, LogarithmicScaleD
 			WriteToString(cb, scale);
 		}
 
-		GeneratedSource.Add(context, $"{name}.g.cs", cb.ToString());
+		context.AddSource($"{name}.g.cs", cb.ToString());
 	}
 
 	private static void WriteScalarFactory(CodeBlocker cb, LogarithmicScaleDefinition scale, string fullType)
diff --git a/Semantics.SourceGenerators/Generators/MagnitudesGenerator.cs b/Semantics.SourceGenerators/Generators/MagnitudesGenerator.cs
index 0073bed9..70132bdc 100644
--- a/Semantics.SourceGenerators/Generators/MagnitudesGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/MagnitudesGenerator.cs
@@ -63,6 +63,6 @@ protected override void Generate(SourceProductionContext context, MagnitudesMeta
 		sourceFileTemplate.Classes.Add(magnitudesClass);
 
 		WriteSourceFileTo(codeBlocker, sourceFileTemplate);
-		GeneratedSource.Add(context, sourceFileTemplate.FileName, codeBlocker.ToString());
+		context.AddSource(sourceFileTemplate.FileName, codeBlocker.ToString());
 	}
 }
diff --git a/Semantics.SourceGenerators/Generators/PhysicalConstantsGenerator.cs b/Semantics.SourceGenerators/Generators/PhysicalConstantsGenerator.cs
index 2eed239e..cf4c9272 100644
--- a/Semantics.SourceGenerators/Generators/PhysicalConstantsGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/PhysicalConstantsGenerator.cs
@@ -180,6 +180,6 @@ protected override void Generate(SourceProductionContext context, DomainsMetadat
 		sourceFileTemplate.Classes.Add(constantsClass);
 
 		WriteSourceFileTo(codeBlocker, sourceFileTemplate);
-		GeneratedSource.Add(context, sourceFileTemplate.FileName, codeBlocker.ToString());
+		context.AddSource(sourceFileTemplate.FileName, codeBlocker.ToString());
 	}
 }
diff --git a/Semantics.SourceGenerators/Generators/PrecisionGenerator.cs b/Semantics.SourceGenerators/Generators/PrecisionGenerator.cs
index 8755673e..1e35230a 100644
--- a/Semantics.SourceGenerators/Generators/PrecisionGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/PrecisionGenerator.cs
@@ -84,6 +84,6 @@ protected override void Generate(SourceProductionContext context, PrecisionMetad
 		sourceFileTemplate.Classes.Add(storageClass);
 
 		WriteSourceFileTo(codeBlocker, sourceFileTemplate);
-		GeneratedSource.Add(context, sourceFileTemplate.FileName, codeBlocker.ToString());
+		context.AddSource(sourceFileTemplate.FileName, codeBlocker.ToString());
 	}
 }
diff --git a/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs b/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
index 5c26cdd3..fe5301ae 100644
--- a/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
@@ -827,7 +827,7 @@ private void EmitV0BaseType(
 		string typeName = v0.Base;
 		string fullType = $"{typeName}<T>";
 
-		using CodeBlocker cb = CodeBlocker.Create();
+		using CodeBlocker cb = CreateCodeBlocker();
 
 		SourceFileTemplate sourceFile = new()
 		{
@@ -906,7 +906,7 @@ private void EmitV0BaseType(
 
 		sourceFile.Classes.Add(cls);
 		WriteSourceFileTo(cb, sourceFile);
-		GeneratedSource.Add(context, sourceFile.FileName, cb.ToString());
+		context.AddSource(sourceFile.FileName, cb.ToString());
 	}
 
 	private void EmitV1BaseType(
@@ -921,7 +921,7 @@ private void EmitV1BaseType(
 		string fullType = $"{typeName}<T>";
 		string? v0TypeName = dim.Quantities.Vector0?.Base;
 
-		using CodeBlocker cb = CodeBlocker.Create();
+		using CodeBlocker cb = CreateCodeBlocker();
 
 		SourceFileTemplate sourceFile = new()
 		{
@@ -992,7 +992,7 @@ private void EmitV1BaseType(
 
 		sourceFile.Classes.Add(cls);
 		WriteSourceFileTo(cb, sourceFile);
-		GeneratedSource.Add(context, sourceFile.FileName, cb.ToString());
+		context.AddSource(sourceFile.FileName, cb.ToString());
 	}
 
 	private static void EmitVectorType(
@@ -1017,7 +1017,7 @@ private static void EmitVectorType(
 		string interfaceName = $"IVector{dims}<{fullType}, T>";
 		string? v0TypeName = dim.Quantities.Vector0?.Base;
 
-		using CodeBlocker cb = CodeBlocker.Create();
+		using CodeBlocker cb = CreateCodeBlocker();
 
 		WriteHeaderTo(cb);
 		cb.WriteLine("#pragma warning disable IDE0040 // Accessibility modifiers required");
@@ -1083,7 +1083,7 @@ private static void EmitVectorType(
 			}
 		}
 
-		GeneratedSource.Add(context, $"{typeName}.g.cs", cb.ToString());
+		context.AddSource($"{typeName}.g.cs", cb.ToString());
 	}
 
 	private void EmitOverloadType(
@@ -1101,7 +1101,7 @@ private void EmitOverloadType(
 		// V0/V1 overloads inherit from PhysicalQuantity
 		if (vectorForm <= 1)
 		{
-			using CodeBlocker cb = CodeBlocker.Create();
+			using CodeBlocker cb = CreateCodeBlocker();
 
 			string interfaceName = vectorForm == 0 ? $"IVector0<{fullType}, T>" : $"IVector1<{fullType}, T>";
 
@@ -1250,7 +1250,7 @@ private void EmitOverloadType(
 
 			sourceFile.Classes.Add(cls);
 			WriteSourceFileTo(cb, sourceFile);
-			GeneratedSource.Add(context, sourceFile.FileName, cb.ToString());
+			context.AddSource(sourceFile.FileName, cb.ToString());
 		}
 		else
 		{
@@ -1280,7 +1280,7 @@ private static void EmitVectorOverloadType(
 		string baseFullType = $"{baseTypeName}<T>";
 		string interfaceName = $"IVector{dims}<{fullType}, T>";
 
-		using CodeBlocker cb = CodeBlocker.Create();
+		using CodeBlocker cb = CreateCodeBlocker();
 
 		WriteHeaderTo(cb);
 		cb.WriteLine("#pragma warning disable IDE0040 // Accessibility modifiers required");
@@ -1319,7 +1319,7 @@ private static void EmitVectorOverloadType(
 			cb.NewLine();
 		}
 
-		GeneratedSource.Add(context, $"{typeName}.g.cs", cb.ToString());
+		context.AddSource($"{typeName}.g.cs", cb.ToString());
 	}
 
 	#endregion
diff --git a/Semantics.SourceGenerators/Generators/UnitsGenerator.cs b/Semantics.SourceGenerators/Generators/UnitsGenerator.cs
index c34ffb78..cf5f1fa4 100644
--- a/Semantics.SourceGenerators/Generators/UnitsGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/UnitsGenerator.cs
@@ -87,7 +87,7 @@ private static void GenerateInner(SourceProductionContext context, UnitsMetadata
 		sourceFileTemplate.Classes.Add(BuildUnitsCatalogue(catalogueUnitNames));
 
 		WriteSourceFileTo(codeBlocker, sourceFileTemplate);
-		GeneratedSource.Add(context, sourceFileTemplate.FileName, codeBlocker.ToString());
+		context.AddSource(sourceFileTemplate.FileName, codeBlocker.ToString());
 	}
 
 	/// <summary>