diff --git a/CLAUDE.md b/CLAUDE.md
index 00df749..65f2ec6 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -304,7 +304,13 @@ arithmetic, so a `decimal` length has 28 significant digits. A value a `double`
 `BigInteger` of 2^2048, is scaled by powers of four into [1, 4) for the seed, and the root is scaled
 back by the matching power of two. A root that does not settle throws `ArithmeticException` rather
 than returning an estimate. The logarithmic scales and the hand-written audio types still compute
-through `double`.
+through `double`, and as of #235 every generated conversion says so in its own XML `<remarks>`
+rather than only here — the method tooltip is where a `decimal` or `PreciseNumber` consumer spends
+the precision, so that is where the cost is stated. `SourceGeneratorTests` counts the remarks
+against the conversions that actually drop to `double`, so a conversion added later cannot ship
+undocumented. If the scales ever compute in `T`'s own arithmetic (option 3 on #235, which wants
+`Exp`/`Log` on `PreciseNumber` first — ktsu-dev/PreciseNumber#81), the remarks become false and
+should be removed with the `double` path rather than left to rot.
 
 `StorageMath` is public API, not just the generator's helper (#239): an application doing its own
 vector math over quantities would otherwise reimplement the root, and worse. `Cbrt`, `RootN` and
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Cents.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Cents.g.cs
index 1d597af..dcae475 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Cents.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Cents.g.cs
@@ -16,6 +16,14 @@ namespace ktsu.Semantics.Quantities;
 /// An octave is 1200 cents: cents = 1200·log2(frequencyRatio).
 /// Logarithmic scales don't obey linear arithmetic, so this type is generated as a
 /// standalone companion (from logarithmic.json) rather than a physical dimension.
+/// <para>
+/// <b>Precision:</b> the conversions to and from the linear counterparts compute in
+/// <see langword="double"/> whatever <typeparamref name="T"/> is, so a value carried in a
+/// storage type wider than <see langword="double"/> — <see langword="decimal"/>, or
+/// <c>PreciseNumber</c> — is accurate to about fifteen significant digits once it has been
+/// through one. Arithmetic, comparison and the raw factory keep every digit
+/// <typeparamref name="T"/> holds; only the logarithm and its inverse do not.
+/// </para>
 /// </remarks>
 /// <typeparam name="T">The floating-point storage type.</typeparam>
 /// <param name="Value">The scale value.</param>
@@ -34,6 +42,13 @@ public readonly partial record struct Cents<T>(T Value) : IComparable<Cents<T>>
 	/// </summary>
 	/// <param name="linear">The linear <see cref="Ratio{T}"/>.</param>
 	/// <returns>A new <see cref="Cents{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public static Cents<T> FromFrequencyRatio(Ratio<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
@@ -44,6 +59,13 @@ public static Cents<T> FromFrequencyRatio(Ratio<T> linear)
 	/// Converts this interval to a frequency ratio using ratio = 2^(cents/1200).
 	/// </summary>
 	/// <returns>The linear <see cref="Ratio{T}"/>.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public Ratio<T> ToFrequencyRatio()
 	{
 		double scaleValue = double.CreateChecked(Value);
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Decibels.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Decibels.g.cs
index 6ffaa34..126e8fa 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Decibels.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Decibels.g.cs
@@ -16,6 +16,14 @@ namespace ktsu.Semantics.Quantities;
 /// Decibels express ratios on a logarithmic scale. Amplitude/field quantities use dB = 20·log10(ratio); power quantities use dB = 10·log10(ratio). A level of 0 dB is unity.
 /// Logarithmic scales don't obey linear arithmetic, so this type is generated as a
 /// standalone companion (from logarithmic.json) rather than a physical dimension.
+/// <para>
+/// <b>Precision:</b> the conversions to and from the linear counterparts compute in
+/// <see langword="double"/> whatever <typeparamref name="T"/> is, so a value carried in a
+/// storage type wider than <see langword="double"/> — <see langword="decimal"/>, or
+/// <c>PreciseNumber</c> — is accurate to about fifteen significant digits once it has been
+/// through one. Arithmetic, comparison and the raw factory keep every digit
+/// <typeparamref name="T"/> holds; only the logarithm and its inverse do not.
+/// </para>
 /// </remarks>
 /// <typeparam name="T">The floating-point storage type.</typeparam>
 /// <param name="Value">The scale value.</param>
@@ -34,6 +42,13 @@ public readonly partial record struct Decibels<T>(T Value) : IComparable<Decibel
 	/// </summary>
 	/// <param name="linear">The linear <see cref="Gain{T}"/>.</param>
 	/// <returns>A new <see cref="Decibels{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public static Decibels<T> FromGain(Gain<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
@@ -44,6 +59,13 @@ public static Decibels<T> FromGain(Gain<T> linear)
 	/// Converts this level to a linear amplitude gain using gain = 10^(dB/20).
 	/// </summary>
 	/// <returns>The linear <see cref="Gain{T}"/>.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public Gain<T> ToAmplitude()
 	{
 		double scaleValue = double.CreateChecked(Value);
@@ -55,6 +77,13 @@ public Gain<T> ToAmplitude()
 	/// </summary>
 	/// <param name="linear">The linear <see cref="Ratio{T}"/>.</param>
 	/// <returns>A new <see cref="Decibels{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public static Decibels<T> FromPowerRatio(Ratio<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
@@ -65,6 +94,13 @@ public static Decibels<T> FromPowerRatio(Ratio<T> linear)
 	/// Converts this level to a linear power ratio using ratio = 10^(dB/10).
 	/// </summary>
 	/// <returns>The linear <see cref="Ratio{T}"/>.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public Ratio<T> ToPower()
 	{
 		double scaleValue = double.CreateChecked(Value);
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/DirectionalityIndex.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/DirectionalityIndex.g.cs
index 6c6c489..051f614 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/DirectionalityIndex.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/DirectionalityIndex.g.cs
@@ -16,6 +16,14 @@ namespace ktsu.Semantics.Quantities;
 /// DI = 10·log10(I_axis / I_average).
 /// Logarithmic scales don't obey linear arithmetic, so this type is generated as a
 /// standalone companion (from logarithmic.json) rather than a physical dimension.
+/// <para>
+/// <b>Precision:</b> the conversions to and from the linear counterparts compute in
+/// <see langword="double"/> whatever <typeparamref name="T"/> is, so a value carried in a
+/// storage type wider than <see langword="double"/> — <see langword="decimal"/>, or
+/// <c>PreciseNumber</c> — is accurate to about fifteen significant digits once it has been
+/// through one. Arithmetic, comparison and the raw factory keep every digit
+/// <typeparamref name="T"/> holds; only the logarithm and its inverse do not.
+/// </para>
 /// </remarks>
 /// <typeparam name="T">The floating-point storage type.</typeparam>
 /// <param name="Value">The scale value.</param>
@@ -34,6 +42,13 @@ public readonly partial record struct DirectionalityIndex<T>(T Value) : ICompara
 	/// </summary>
 	/// <param name="linear">The linear <see cref="Ratio{T}"/>.</param>
 	/// <returns>A new <see cref="DirectionalityIndex{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public static DirectionalityIndex<T> FromIntensityRatio(Ratio<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
@@ -44,6 +59,13 @@ public static DirectionalityIndex<T> FromIntensityRatio(Ratio<T> linear)
 	/// Converts this index to the linear intensity ratio using ratio = 10^(DI/10).
 	/// </summary>
 	/// <returns>The linear <see cref="Ratio{T}"/>.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public Ratio<T> ToIntensityRatio()
 	{
 		double scaleValue = double.CreateChecked(Value);
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/PH.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/PH.g.cs
index 98659b4..ba4dacc 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/PH.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/PH.g.cs
@@ -16,6 +16,14 @@ namespace ktsu.Semantics.Quantities;
 /// pH is a logarithmic scale over the linear Concentration quantity (stored in the SI base mol/m³; 1 mol/L = 1000 mol/m³).
 /// Logarithmic scales don't obey linear arithmetic, so this type is generated as a
 /// standalone companion (from logarithmic.json) rather than a physical dimension.
+/// <para>
+/// <b>Precision:</b> the conversions to and from the linear counterparts compute in
+/// <see langword="double"/> whatever <typeparamref name="T"/> is, so a value carried in a
+/// storage type wider than <see langword="double"/> — <see langword="decimal"/>, or
+/// <c>PreciseNumber</c> — is accurate to about fifteen significant digits once it has been
+/// through one. Arithmetic, comparison and the raw factory keep every digit
+/// <typeparamref name="T"/> holds; only the logarithm and its inverse do not.
+/// </para>
 /// </remarks>
 /// <typeparam name="T">The floating-point storage type.</typeparam>
 /// <param name="Value">The scale value.</param>
@@ -34,6 +42,13 @@ public readonly partial record struct PH<T>(T Value) : IComparable<PH<T>>
 	/// </summary>
 	/// <param name="linear">The linear <see cref="Concentration{T}"/>.</param>
 	/// <returns>A new <see cref="PH{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public static PH<T> FromHydrogenConcentration(Concentration<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
@@ -45,6 +60,13 @@ public static PH<T> FromHydrogenConcentration(Concentration<T> linear)
 	/// Converts this pH to the equivalent hydrogen-ion concentration using [H⁺] = 10^(−pH) mol/L.
 	/// </summary>
 	/// <returns>The linear <see cref="Concentration{T}"/>.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public Concentration<T> ToHydrogenConcentration()
 	{
 		double scaleValue = double.CreateChecked(Value);
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Semitones.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Semitones.g.cs
index bc7c03c..b39fc7c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Semitones.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Semitones.g.cs
@@ -16,6 +16,14 @@ namespace ktsu.Semantics.Quantities;
 /// An octave is 12 semitones: semitones = 12·log2(frequencyRatio).
 /// Logarithmic scales don't obey linear arithmetic, so this type is generated as a
 /// standalone companion (from logarithmic.json) rather than a physical dimension.
+/// <para>
+/// <b>Precision:</b> the conversions to and from the linear counterparts compute in
+/// <see langword="double"/> whatever <typeparamref name="T"/> is, so a value carried in a
+/// storage type wider than <see langword="double"/> — <see langword="decimal"/>, or
+/// <c>PreciseNumber</c> — is accurate to about fifteen significant digits once it has been
+/// through one. Arithmetic, comparison and the raw factory keep every digit
+/// <typeparamref name="T"/> holds; only the logarithm and its inverse do not.
+/// </para>
 /// </remarks>
 /// <typeparam name="T">The floating-point storage type.</typeparam>
 /// <param name="Value">The scale value.</param>
@@ -34,6 +42,13 @@ public readonly partial record struct Semitones<T>(T Value) : IComparable<Semito
 	/// </summary>
 	/// <param name="linear">The linear <see cref="Ratio{T}"/>.</param>
 	/// <returns>A new <see cref="Semitones{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public static Semitones<T> FromFrequencyRatio(Ratio<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
@@ -44,6 +59,13 @@ public static Semitones<T> FromFrequencyRatio(Ratio<T> linear)
 	/// Converts this interval to a frequency ratio using ratio = 2^(semitones/12).
 	/// </summary>
 	/// <returns>The linear <see cref="Ratio{T}"/>.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public Ratio<T> ToFrequencyRatio()
 	{
 		double scaleValue = double.CreateChecked(Value);
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundIntensityLevel.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundIntensityLevel.g.cs
index 260a2a0..ef12bdc 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundIntensityLevel.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundIntensityLevel.g.cs
@@ -16,6 +16,14 @@ namespace ktsu.Semantics.Quantities;
 /// SIL is a logarithmic power quantity: SIL = 10·log10(I / I₀) with I₀ = 10⁻¹² W/m².
 /// Logarithmic scales don't obey linear arithmetic, so this type is generated as a
 /// standalone companion (from logarithmic.json) rather than a physical dimension.
+/// <para>
+/// <b>Precision:</b> the conversions to and from the linear counterparts compute in
+/// <see langword="double"/> whatever <typeparamref name="T"/> is, so a value carried in a
+/// storage type wider than <see langword="double"/> — <see langword="decimal"/>, or
+/// <c>PreciseNumber</c> — is accurate to about fifteen significant digits once it has been
+/// through one. Arithmetic, comparison and the raw factory keep every digit
+/// <typeparamref name="T"/> holds; only the logarithm and its inverse do not.
+/// </para>
 /// </remarks>
 /// <typeparam name="T">The floating-point storage type.</typeparam>
 /// <param name="Value">The scale value.</param>
@@ -34,6 +42,13 @@ public readonly partial record struct SoundIntensityLevel<T>(T Value) : ICompara
 	/// </summary>
 	/// <param name="linear">The linear <see cref="SoundIntensity{T}"/>.</param>
 	/// <returns>A new <see cref="SoundIntensityLevel{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public static SoundIntensityLevel<T> FromSoundIntensity(SoundIntensity<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
@@ -45,6 +60,13 @@ public static SoundIntensityLevel<T> FromSoundIntensity(SoundIntensity<T> linear
 	/// Converts this level to the equivalent linear sound intensity using I = I₀·10^(SIL/10).
 	/// </summary>
 	/// <returns>The linear <see cref="SoundIntensity{T}"/>.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public SoundIntensity<T> ToSoundIntensity()
 	{
 		double scaleValue = double.CreateChecked(Value);
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundPowerLevel.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundPowerLevel.g.cs
index 695252b..be113e4 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundPowerLevel.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundPowerLevel.g.cs
@@ -16,6 +16,14 @@ namespace ktsu.Semantics.Quantities;
 /// SWL is a logarithmic power quantity: SWL = 10·log10(P / P₀) with P₀ = 10⁻¹² W.
 /// Logarithmic scales don't obey linear arithmetic, so this type is generated as a
 /// standalone companion (from logarithmic.json) rather than a physical dimension.
+/// <para>
+/// <b>Precision:</b> the conversions to and from the linear counterparts compute in
+/// <see langword="double"/> whatever <typeparamref name="T"/> is, so a value carried in a
+/// storage type wider than <see langword="double"/> — <see langword="decimal"/>, or
+/// <c>PreciseNumber</c> — is accurate to about fifteen significant digits once it has been
+/// through one. Arithmetic, comparison and the raw factory keep every digit
+/// <typeparamref name="T"/> holds; only the logarithm and its inverse do not.
+/// </para>
 /// </remarks>
 /// <typeparam name="T">The floating-point storage type.</typeparam>
 /// <param name="Value">The scale value.</param>
@@ -34,6 +42,13 @@ public readonly partial record struct SoundPowerLevel<T>(T Value) : IComparable<
 	/// </summary>
 	/// <param name="linear">The linear <see cref="SoundPower{T}"/>.</param>
 	/// <returns>A new <see cref="SoundPowerLevel{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public static SoundPowerLevel<T> FromSoundPower(SoundPower<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
@@ -45,6 +60,13 @@ public static SoundPowerLevel<T> FromSoundPower(SoundPower<T> linear)
 	/// Converts this level to the equivalent linear sound power using P = P₀·10^(SWL/10).
 	/// </summary>
 	/// <returns>The linear <see cref="SoundPower{T}"/>.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public SoundPower<T> ToSoundPower()
 	{
 		double scaleValue = double.CreateChecked(Value);
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundPressureLevel.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundPressureLevel.g.cs
index 0f38e16..e47b47c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundPressureLevel.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundPressureLevel.g.cs
@@ -16,6 +16,14 @@ namespace ktsu.Semantics.Quantities;
 /// SPL is a logarithmic field quantity: SPL = 20·log10(p / p₀) with p₀ = 20 µPa.
 /// Logarithmic scales don't obey linear arithmetic, so this type is generated as a
 /// standalone companion (from logarithmic.json) rather than a physical dimension.
+/// <para>
+/// <b>Precision:</b> the conversions to and from the linear counterparts compute in
+/// <see langword="double"/> whatever <typeparamref name="T"/> is, so a value carried in a
+/// storage type wider than <see langword="double"/> — <see langword="decimal"/>, or
+/// <c>PreciseNumber</c> — is accurate to about fifteen significant digits once it has been
+/// through one. Arithmetic, comparison and the raw factory keep every digit
+/// <typeparamref name="T"/> holds; only the logarithm and its inverse do not.
+/// </para>
 /// </remarks>
 /// <typeparam name="T">The floating-point storage type.</typeparam>
 /// <param name="Value">The scale value.</param>
@@ -34,6 +42,13 @@ public readonly partial record struct SoundPressureLevel<T>(T Value) : IComparab
 	/// </summary>
 	/// <param name="linear">The linear <see cref="SoundPressure{T}"/>.</param>
 	/// <returns>A new <see cref="SoundPressureLevel{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public static SoundPressureLevel<T> FromSoundPressure(SoundPressure<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
@@ -45,6 +60,13 @@ public static SoundPressureLevel<T> FromSoundPressure(SoundPressure<T> linear)
 	/// Converts this level to the equivalent linear sound pressure using p = p₀·10^(SPL/20).
 	/// </summary>
 	/// <returns>The linear <see cref="SoundPressure{T}"/>.</returns>
+	/// <remarks>
+	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
+	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
+	/// result is converted back. A storage type wider than <see langword="double"/> —
+	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
+	/// significant digits across this conversion, rather than the precision it is capable of.
+	/// </remarks>
 	public SoundPressure<T> ToSoundPressure()
 	{
 		double scaleValue = double.CreateChecked(Value);
diff --git a/Semantics.SourceGenerators/Generators/LogarithmicScalesGenerator.cs b/Semantics.SourceGenerators/Generators/LogarithmicScalesGenerator.cs
index 83cb0ce..dfdef78 100644
--- a/Semantics.SourceGenerators/Generators/LogarithmicScalesGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/LogarithmicScalesGenerator.cs
@@ -79,6 +79,14 @@ private static void EmitScale(SourceProductionContext context, LogarithmicScaleD
 
 		cb.WriteLine("/// Logarithmic scales don't obey linear arithmetic, so this type is generated as a");
 		cb.WriteLine("/// standalone companion (from logarithmic.json) rather than a physical dimension.");
+		cb.WriteLine("/// <para>");
+		cb.WriteLine("/// <b>Precision:</b> the conversions to and from the linear counterparts compute in");
+		cb.WriteLine("/// <see langword=\"double\"/> whatever <typeparamref name=\"T\"/> is, so a value carried in a");
+		cb.WriteLine("/// storage type wider than <see langword=\"double\"/> — <see langword=\"decimal\"/>, or");
+		cb.WriteLine("/// <c>PreciseNumber</c> — is accurate to about fifteen significant digits once it has been");
+		cb.WriteLine("/// through one. Arithmetic, comparison and the raw factory keep every digit");
+		cb.WriteLine("/// <typeparamref name=\"T\"/> holds; only the logarithm and its inverse do not.");
+		cb.WriteLine("/// </para>");
 		cb.WriteLine("/// </remarks>");
 		cb.WriteLine("/// <typeparam name=\"T\">The floating-point storage type.</typeparam>");
 		cb.WriteLine("/// <param name=\"Value\">The scale value.</param>");
@@ -122,6 +130,29 @@ private static void WriteScalarFactory(CodeBlocker cb, LogarithmicScaleDefinitio
 		cb.NewLine();
 	}
 
+	/// <summary>
+	/// Emits the remarks stating that a conversion computes in <see langword="double"/> regardless
+	/// of the storage type.
+	/// </summary>
+	/// <param name="cb">The code blocker to write to.</param>
+	/// <remarks>
+	/// On the conversion rather than only on the type, because the call site is where a caller
+	/// spends the precision, and the method's own tooltip is what they see there. The storage type
+	/// is otherwise exact — unit factors, metric magnitudes and vector lengths all compute in
+	/// <c>T</c>'s own arithmetic — so a scale quietly dropping to fifteen digits is a surprise
+	/// worth stating rather than leaving to be discovered in a result.
+	/// </remarks>
+	private static void WriteDoublePrecisionRemarks(CodeBlocker cb)
+	{
+		cb.WriteLine("/// <remarks>");
+		cb.WriteLine("/// Computes in <see langword=\"double\"/> whatever <typeparamref name=\"T\"/> is: the value is");
+		cb.WriteLine("/// converted to <see langword=\"double\"/>, the logarithm or power is taken there, and the");
+		cb.WriteLine("/// result is converted back. A storage type wider than <see langword=\"double\"/> —");
+		cb.WriteLine("/// <see langword=\"decimal\"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen");
+		cb.WriteLine("/// significant digits across this conversion, rather than the precision it is capable of.");
+		cb.WriteLine("/// </remarks>");
+	}
+
 	private static void WriteConversion(CodeBlocker cb, LogarithmicScaleDefinition scale, LogarithmicConversionDefinition conversion, string fullType)
 	{
 		string linear = conversion.Linear;
@@ -145,6 +176,7 @@ private static void WriteConversion(CodeBlocker cb, LogarithmicScaleDefinition s
 		cb.WriteLine(Emit.SummaryClose);
 		cb.WriteLine($"/// <param name=\"linear\">The linear <see cref=\"{linear}{{T}}\"/>.</param>");
 		cb.WriteLine($"/// <returns>A new <see cref=\"{scale.Name}{{T}}\"/>. A linear value of zero maps to negative infinity.</returns>");
+		WriteDoublePrecisionRemarks(cb);
 		cb.WriteLine($"public static {fullType} {fromName}({linear}<T> linear)");
 		using (new Scope(cb))
 		{
@@ -168,6 +200,7 @@ private static void WriteConversion(CodeBlocker cb, LogarithmicScaleDefinition s
 		cb.WriteLine($"/// {conversion.ToSummary ?? $"Converts this value to the linear {linear}."}");
 		cb.WriteLine(Emit.SummaryClose);
 		cb.WriteLine($"/// <returns>The linear <see cref=\"{linear}{{T}}\"/>.</returns>");
+		WriteDoublePrecisionRemarks(cb);
 		cb.WriteLine($"public {linear}<T> {toName}()");
 		using (new Scope(cb))
 		{
diff --git a/Semantics.Test/Quantities/SourceGeneratorTests.cs b/Semantics.Test/Quantities/SourceGeneratorTests.cs
index d89d3f6..4bc2c57 100644
--- a/Semantics.Test/Quantities/SourceGeneratorTests.cs
+++ b/Semantics.Test/Quantities/SourceGeneratorTests.cs
@@ -27,6 +27,13 @@ public class SourceGeneratorTests
 	/// <summary>The header every generated file is expected to begin with.</summary>
 	private const string ExpectedHeader = "// Copyright (c) 2023-2026 ktsu-dev contributors\n// <auto-generated />";
 
+	/// <summary>The sentence every logarithmic conversion computing in double is expected to carry.</summary>
+	private const string DoublePrecisionRemark =
+		"Computes in <see langword=\"double\"/> whatever <typeparamref name=\"T\"/> is";
+
+	/// <summary>The line that marks a conversion body actually dropping to double.</summary>
+	private const string DoubleConversionMarker = "= double.CreateChecked(";
+
 	private static string MetadataDirectory => Path.Combine(AppContext.BaseDirectory, "GeneratorMetadata");
 
 	private static GeneratorHarness Harness => new(MetadataDirectory);
@@ -101,6 +108,68 @@ public void QuantitiesGenerator_EmitsTheExpectedBreadthOfTypes()
 		Assert.IsGreaterThan(50, result.GeneratedSources.Length);
 	}
 
+	/// <summary>
+	/// Every logarithmic-scale conversion that computes in <see langword="double"/> carries XML
+	/// remarks saying so.
+	/// </summary>
+	/// <remarks>
+	/// The conversions convert to <see langword="double"/>, take the logarithm or power there, and
+	/// convert back, so a <see langword="decimal"/> or <c>PreciseNumber</c> scale keeps about fifteen
+	/// significant digits across one. Everything else about these types is exact in the storage type,
+	/// which is what makes the drop worth stating at the call site rather than leaving to be found in
+	/// a result. Counted rather than spot-checked, so a conversion added later cannot ship
+	/// undocumented.
+	/// </remarks>
+	[TestMethod]
+	public void LogarithmicScalesGenerator_DocumentsEveryConversionThatComputesInDouble()
+	{
+		GeneratorRunResult result = Harness.Run(new LogarithmicScalesGenerator());
+
+		Assert.IsGreaterThan(0, result.GeneratedSources.Length, "LogarithmicScalesGenerator produced no sources.");
+
+		int documented = 0;
+		foreach (GeneratedSourceResult source in result.GeneratedSources)
+		{
+			string text = source.SourceText.ToString();
+			int conversions = Occurrences(text, DoubleConversionMarker);
+			int remarks = Occurrences(text, DoublePrecisionRemark);
+
+			Assert.AreEqual(
+				conversions,
+				remarks,
+				$"{source.HintName} has {conversions} conversion(s) computing in double but {remarks} " +
+				$"carrying the precision remarks. A conversion that drops to double has to say so in " +
+				$"its own XML docs, because the method's tooltip is where a caller spending that " +
+				$"precision would see it.");
+
+			documented += remarks;
+		}
+
+		// Reaching zero would mean the double path is gone — issue #235's option 3 landed, and the
+		// conversions compute in T's own arithmetic. The remarks would then be false and should be
+		// removed along with this test, rather than this assertion being relaxed.
+		Assert.IsGreaterThan(0, documented, "No logarithmic-scale conversion carries the precision remarks.");
+	}
+
+	/// <summary>
+	/// Counts non-overlapping occurrences of a substring.
+	/// </summary>
+	/// <param name="text">The text to search.</param>
+	/// <param name="value">The substring to count.</param>
+	/// <returns>The number of occurrences.</returns>
+	private static int Occurrences(string text, string value)
+	{
+		int count = 0;
+		for (int index = text.IndexOf(value, StringComparison.Ordinal);
+			index >= 0;
+			index = text.IndexOf(value, index + value.Length, StringComparison.Ordinal))
+		{
+			count++;
+		}
+
+		return count;
+	}
+
 	[TestMethod]
 	public void Generator_WithMalformedMetadata_ReportsDiagnosticInsteadOfThrowing()
 	{